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
# 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)
static inline int foo1() {
static inline int foo2() {
AC_DEFINE(inline, ,[Define to empty if your compiler does not support "static inline".])])
AC_CHECK_TYPE(ssize_t, int)
AC_CHECK_TYPE(uintptr_t,unsigned long)
[AC_DEFINE(ISC_SOCKADDR_LEN_T, socklen_t)],
int getsockname(int, struct sockaddr *, size_t *);
[AC_DEFINE(ISC_SOCKADDR_LEN_T, size_t)],
[AC_DEFINE(ISC_SOCKADDR_LEN_T, int)])
AC_SUBST(ISC_SOCKADDR_LEN_T)
AC_MSG_CHECKING(for long long)
AC_TRY_COMPILE([],[long long i = 0; return (0);],
ISC_PLATFORM_HAVELONGLONG="#define ISC_PLATFORM_HAVELONGLONG 1"],
ISC_PLATFORM_HAVELONGLONG="#undef ISC_PLATFORM_HAVELONGLONG"])
AC_SUBST(ISC_PLATFORM_HAVELONGLONG)
# check for uname library routine
AC_MSG_CHECKING(for uname)
printf("running on %s %s %s for %s\n",
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));],
ISC_PLATFORM_NORETURN_PRE="#define ISC_PLATFORM_NORETURN_PRE"
ISC_PLATFORM_NORETURN_POST="#define ISC_PLATFORM_NORETURN_POST __attribute__((noreturn))"],
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)
ISC_PLATFORM_HAVELIFCONF="#define ISC_PLATFORM_HAVELIFCONF 1"],
ISC_PLATFORM_HAVELIFCONF="#undef ISC_PLATFORM_HAVELIFCONF"])
AC_SUBST(ISC_PLATFORM_HAVELIFCONF)
# check if we have kqueue
[ --enable-kqueue use BSD kqueue when available [[default=yes]]],
want_kqueue="$enableval", want_kqueue="yes")
AC_CHECK_FUNC(kqueue, ac_cv_have_kqueue=yes, ac_cv_have_kqueue=no)
case $ac_cv_have_kqueue in
ISC_PLATFORM_HAVEKQUEUE="#define ISC_PLATFORM_HAVEKQUEUE 1"
ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"
ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"
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.
[ --enable-epoll use Linux epoll when available [[default=auto]]],
want_epoll="$enableval", want_epoll="auto")
AC_MSG_CHECKING(epoll support)
ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"],
ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"],
ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"])
ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"
ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"
AC_SUBST(ISC_PLATFORM_HAVEEPOLL)
[ --enable-devpoll use
/dev/poll when available [[default=yes]]],
want_devpoll="$enableval", want_devpoll="yes")
ISC_PLATFORM_HAVEDEVPOLL="#define ISC_PLATFORM_HAVEDEVPOLL 1"
ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"
ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"
AC_SUBST(ISC_PLATFORM_HAVEDEVPOLL)
case $ac_cv_header_unistd_h in
[fd_set read_set; return (0);],
ISC_PLATFORM_NEEDSYSSELECTH="#undef ISC_PLATFORM_NEEDSYSSELECTH"
LWRES_PLATFORM_NEEDSYSSELECTH="#undef LWRES_PLATFORM_NEEDSYSSELECTH"],
case $ac_cv_header_sys_select_h in
ISC_PLATFORM_NEEDSYSSELECTH="#define ISC_PLATFORM_NEEDSYSSELECTH 1"
LWRES_PLATFORM_NEEDSYSSELECTH="#define LWRES_PLATFORM_NEEDSYSSELECTH 1"
case $ac_cv_header_sys_select_h in
ISC_PLATFORM_NEEDSYSSELECTH="#define ISC_PLATFORM_NEEDSYSSELECTH 1"
LWRES_PLATFORM_NEEDSYSSELECTH="#define LWRES_PLATFORM_NEEDSYSSELECTH 1"
AC_SUBST(ISC_PLATFORM_NEEDSYSSELECTH)
AC_SUBST(LWRES_PLATFORM_NEEDSYSSELECTH)
# Find the machine's endian flavor.
[ --with-geoip=PATH Build with GeoIP support (yes|no|path)],
use_geoip="$withval", use_geoip="no")
if test "$use_geoip" = "yes"
AC_MSG_CHECKING([for GeoIP support])
AC_MSG_RESULT([disabled])
if test -d "$use_geoip" -o -L "$use_geoip"
netbsd*|openbsd*|solaris*)
elif test "$use_geoip" = "yes"
AC_MSG_ERROR([GeoIP path not found])
AC_MSG_ERROR([GeoIP path $use_geoip does not exist])
[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_CHECKING([for GeoIP Country IPv6 support])
GeoIP_country_name_by_ipnum_v6(NULL, in6);
AC_DEFINE(HAVE_GEOIP_V6, 1, Build with GeoIP Country IPv6 support)
AC_MSG_CHECKING([for GeoIP City IPv6 support])
int i = GEOIP_CITY_EDITION_REV0_V6;
GeoIP_record_by_ipnum_v6(NULL, in6);
AC_DEFINE(HAVE_GEOIP_CITY_V6, 1, Build with GeoIP City IPv6 support)
AC_MSG_CHECKING(for GSSAPI library)
[ --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.
*/krb5-config|krb5-config)
AC_MSG_RESULT(trying $use_gssapi)
if test "$use_gssapi" = krb5-config
AC_PATH_PROG(KRB5_CONFIG, $use_gssapi)
KRB5_CONFIG="$use_gssapi"
gssapi_cflags=`$KRB5_CONFIG --cflags gssapi`
gssapi_libs=`$KRB5_CONFIG --libs gssapi`
saved_cppflags="$CPPFLAGS"
CPPFLAGS="$gssapi_cflags $CPPFLAGS"
[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"
[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"
CPPFLAGS="$saved_cppflags"
AC_MSG_CHECKING([krb5-config linking as $LIBS])
AC_TRY_LINK( , [gss_acquire_cred();krb5_init_context()],
gssapi_linked=yes, gssapi_linked=no)
yes) AC_MSG_RESULT([krb5-config: linked]);;
no) AC_MSG_RESULT([krb5-config: could not determine proper GSSAPI linkage])
if test "$use_gssapi" = "yes"; then
AC_MSG_CHECKING([for GSSAPI library, non krb5-config method])
# 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 "$use_gssapi" = "yes"
# first, deal with the obvious
AC_MSG_ERROR([--with-gssapi must specify a path])
*/krb5-config|krb5-config)
DST_GSSAPI_INC="$gssapi_cflags"
DNS_GSSAPI_LIBS="$gssapi_libs"
saved_cppflags="$CPPFLAGS"
[ISC_PLATFORM_GSSAPIHEADER="#define ISC_PLATFORM_GSSAPIHEADER <$ac_header>"
gssapi_hack="#include <$ac_header>"])
if test "$ISC_PLATFORM_GSSAPIHEADER" = ""; then
[ISC_PLATFORM_GSSAPI_KRB5_HEADER="#define ISC_PLATFORM_GSSAPI_KRB5_HEADER <$ac_header>"
gssapi_krb5_hack="#include <$ac_header>"])
[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])
# 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.
"-lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err" \
"-lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err -lresolv" \
"-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" \
# Note that this does not include $saved_libs, because
# on FreeBSD machines this configure script has added
# -lgssapi_krb5 test succeed with shared libraries even
# when you are trying to build with KTH in
/usr/lib.
if test "$use_gssapi" = "/usr"
AC_MSG_CHECKING(linking as $TRY_LIBS)
] , [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);
gssapi_linked=yes, gssapi_linked=no)
yes) AC_MSG_RESULT(yes); break ;;
CPPFLAGS="$saved_cppflags"
no) AC_MSG_ERROR(could not determine proper GSSAPI linkage) ;;
# XXXDCL Major kludge. Tries to cope with KTH in
/usr/lib # 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
if test "$use_gssapi" = "/usr" -a \
case "$FIX_KTH_VS_MIT" in
case "$enable_static_linking" in
yes) gssapi_lib_suffix=".a" ;;
*) gssapi_lib_suffix=".so" ;;
-e s%$%$gssapi_lib_suffix%`
NEW_LIBS="$NEW_LIBS $new_lib"
AC_MSG_ERROR([KTH vs MIT Kerberos confusion!])
AC_SUBST(ISC_PLATFORM_HAVEGSSAPI)
AC_SUBST(ISC_PLATFORM_GSSAPIHEADER)
AC_SUBST(ISC_PLATFORM_GSSAPI_KRB5_HEADER)
AC_SUBST(ISC_PLATFORM_KRB5HEADER)
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)
[ --with-randomdev=PATH Specify path for random device],
use_randomdev="$withval", use_randomdev="unspec")
case "$cross_compiling" in
AC_MSG_RESULT(unspecified)
AC_MSG_ERROR([ need --with-randomdev=PATH or --with-randomdev=no])
AC_MSG_RESULT($devrandom)
AC_CHECK_FILE($devrandom,
AC_DEFINE_UNQUOTED(PATH_RANDOMDEV,
AC_MSG_ERROR([--with-randomdev must specify a path])
AC_DEFINE_UNQUOTED(PATH_RANDOMDEV, "$use_randomdev")
AC_MSG_RESULT(using "$use_randomdev")
# Only check dsa signature generation on these platforms when performing
# Do we have arc4random(), etc ? arc4random_addrandom() has been removed
# from OpenBSD 5.5 onwards.
AC_CHECK_FUNC(arc4random, AC_DEFINE(HAVE_ARC4RANDOM))
AC_CHECK_FUNC(arc4random_addrandom, AC_DEFINE(HAVE_ARC4RANDOM_ADDRANDOM))
if test "X$GCC" = "Xyes"; then
CCNOOPT="$CCNOOPT -pthread"
STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
CCNOOPT="$CCNOOPT -pthread"
STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
CCNOOPT="$CCNOOPT -pthread"
STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
*-sco-sysv*uw*|*-*-sysv*UnixWare*)
CCNOOPT="$CCNOOPT -Kthread"
CCNOOPT="$CCNOOPT -Kpthread"
ALWAYS_DEFINES="-D_REENTRANT"
ISC_PLATFORM_USETHREADS="#define ISC_PLATFORM_USETHREADS 1"
THREADOPTOBJS='${THREADOPTOBJS}'
THREADOPTSRCS='${THREADOPTSRCS}'
# We'd like to use sigwait() too
AC_CHECK_LIB(pthread, 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),)
[ --with-locktype=ARG Specify mutex lock type (adaptive or standard)],
locktype="$withval", locktype="adaptive")
AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
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) ])
AC_MSG_RESULT(using standard lock type)
AC_MSG_ERROR([You must specify "adaptive" or "standard" for --with-locktype.])
AC_CHECK_LIB(rt, sched_yield)
AC_CHECK_FUNCS(sched_yield pthread_yield pthread_yield_np)
# Additional OS-specific issues related to pthreads and sigwait.
# One more place to look for sigwait.
AC_CHECK_LIB(c_r, sigwait, AC_DEFINE(HAVE_SIGWAIT),)
*-freebsd5.[[012]]|*-freebsd5.[[012]].*);;
*-freebsd5.[[3456789]]|*-freebsd5.[[3456789]].*)
AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
# BSDI 3.0 through 4.0.1 needs pthread_init() to be
# called before certain pthreads calls. This is deprecated
AC_DEFINE(NEED_PTHREAD_INIT)
# LinuxThreads requires some changes to the way we
AC_DEFINE(HAVE_LINUXTHREADS)
# Ensure the right sigwait() semantics on Solaris and make
# sure we call pthread_setconcurrency.
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)
# Look for sysconf to allow detection of the number of processors.
AC_CHECK_FUNC(sysconf, AC_DEFINE(HAVE_SYSCONF),)
ISC_PLATFORM_USETHREADS="#undef ISC_PLATFORM_USETHREADS"
AC_SUBST(ISC_PLATFORM_USETHREADS)
ISC_THREAD_DIR=$thread_dir
AC_MSG_CHECKING(for libtool)
[ --with-libtool use GNU libtool],
use_libtool="$withval", use_libtool="no")
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'
INSTALL_LIBRARY='${INSTALL_PROGRAM}'
*) LIBTOOL_ALLOW_UNDEFINED= ;;
INSTALL_LIBRARY='${INSTALL_DATA}'
AC_SUBST(INSTALL_LIBRARY)
# was --enable-native-pkcs11 specified?
# (note it implies both --without-openssl and --with-pkcs11)
AC_ARG_ENABLE(native-pkcs11,
[ --enable-native-pkcs11 use native PKCS11 for all crypto [[default=no]]],
want_native_pkcs11="$enableval", want_native_pkcs11="no")
# was --with-openssl specified?
[ --with-openssl[=PATH] Build with OpenSSL [yes|no|path].
(Crypto is required for DNSSEC)],
use_openssl="$withval", use_openssl="auto")
# was --with-pkcs11 specified?
[ --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-aes specified
AC_ARG_WITH(ecdsa, [ --with-ecdsa Crypto ECDSA],
with_ecdsa="$withval", with_ecdsa="auto")
AC_ARG_WITH(gost, [ --with-gost Crypto GOST [yes|no|raw|asn1].],
with_gost="$withval", with_gost="auto")
AC_ARG_WITH(aes, [ --with-aes Crypto AES],
with_aes="$withval", with_aes="checkcc")
# was --enable-openssl-hash specified?
AC_ARG_ENABLE(openssl-hash,
[ --enable-openssl-hash use OpenSSL for hash functions [[default=no]]],
want_openssl_hash="$enableval", want_openssl_hash="checkcc")
# Client Cookie algorithm choice
[ --with-cc-alg=ALG choose the algorithm for Client Cookie [[aes|sha1|sha256]]],
with_cc_alg="$withval", with_cc_alg="auto")
if test "$with_aes" != "no"
if test "$with_aes" != "no"
if test "with_aes" = "checkcc"
AC_MSG_CHECKING(for OpenSSL library)
if test "$want_native_pkcs11" = "yes"
use_openssl="native_pkcs11"
AC_MSG_RESULT(use of native PKCS11 instead)
if test "$use_openssl" = "auto"
AC_DEFINE(PREFER_GOSTASN1, 1,
[Define if GOST private keys are encoded in ASN.1.])
AC_MSG_ERROR(unknown GOST private key encoding)
AC_MSG_RESULT(disabled because of native PKCS11)
[OpenSSL was not found in any of $openssldirs; use --with-openssl=/path
If you don't want OpenSSL, use --without-openssl])
if test "$want_native_pkcs11" = "yes"
AC_MSG_ERROR([OpenSSL and native PKCS11 cannot be used together.])
if test "$use_openssl" = "yes"
# User did not specify a path - guess it
if test "$use_openssl" = "yes"
[OpenSSL was not found in any of $openssldirs; use --with-openssl=/path])
if test "$use_openssl" = "/usr"
DST_OPENSSL_LIBS="-lcrypto"
# 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.
CFLAGS="$CFLAGS $DST_OPENSSL_INC"
LIBS="$LIBS $DST_OPENSSL_LIBS"
AC_MSG_CHECKING(whether linking with OpenSSL works)
AC_MSG_ERROR(Could not run test program using OpenSSL from
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)
],[ DSO_METHOD_dlfcn(); ],
DST_OPENSSL_LIBS="$DST_OPENSSL_LIBS -ldl"
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,
[AC_HELP_STRING([--enable-openssl-version-check],
[check OpenSSL version @<:@default=yes@:>@])])
case "$enable_openssl_version_check" in
AC_MSG_CHECKING(OpenSSL library version)
if ((OPENSSL_VERSION_NUMBER >= 0x009070cfL &&
OPENSSL_VERSION_NUMBER < 0x00908000L) ||
(OPENSSL_VERSION_NUMBER >= 0x0090804fL &&
OPENSSL_VERSION_NUMBER < 0x10002000L) ||
OPENSSL_VERSION_NUMBER >= 0x1000205fL)
printf("\n\nFound OPENSSL_VERSION_NUMBER %#010x\n",
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");
[AC_MSG_RESULT(not compatible)
[AC_MSG_RESULT(assuming target platform has compatible version)])
AC_MSG_RESULT(Skipped OpenSSL version check)
AC_MSG_CHECKING(for OpenSSL DSA support)
AC_DEFINE(HAVE_OPENSSL_DSA)
AC_CHECK_FUNCS(EVP_sha256 EVP_sha384 EVP_sha512)
AC_MSG_CHECKING(for OpenSSL ECDSA support)
#if !defined(HAVE_EVP_SHA256) || !defined(HAVE_EVP_SHA384)
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)
[AC_MSG_RESULT(using --with-ecdsa)])
no) AC_MSG_ERROR([ecdsa not supported]) ;;
*) AC_MSG_ERROR([need --with-ecdsa=[[yes or no]]]) ;;
AC_DEFINE(HAVE_OPENSSL_ECDSA, 1,
[Define if your OpenSSL version supports ECDSA.])
AC_MSG_CHECKING(for OpenSSL GOST support)
#if (OPENSSL_VERSION_NUMBER >= 0x10000000L)
e = ENGINE_by_id("gost");
[AC_MSG_RESULT(using --with-gost)])
no) AC_MSG_ERROR([gost not supported]) ;;
*) AC_MSG_ERROR([need --with-gost=[[yes, no, raw or asn1]]]) ;;
OPENSSLGOSTLINKOBJS='${OPENSSLGOSTLINKOBJS}'
OPENSSLGOSTLINKSRCS='${OPENSSLGOSTLINKSRCS}'
AC_DEFINE(HAVE_OPENSSL_GOST, 1,
[Define if your OpenSSL version supports GOST.])
AC_MSG_CHECKING(for OpenSSL AES support)
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)
[AC_CHECK_FUNC(AES_encrypt,
[AC_MSG_RESULT(using --with-aes)
# Expect cross-compiling with a modern OpenSSL
if test "$with_aes" = "yes"
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"
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"
OPENSSLLINKOBJS='${OPENSSLLINKOBJS}'
OPENSSLLINKSRCS='${OPENSSLLINKSRCS}'
# 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(OPENSSLGOSTLINKOBJS)
AC_SUBST(OPENSSLGOSTLINKSRCS)
AC_SUBST(OPENSSLLINKOBJS)
AC_SUBST(OPENSSLLINKSRCS)
DNS_CRYPTO_LIBS="$DNS_CRYPTO_LIBS $DST_OPENSSL_LIBS"
ISC_PLATFORM_WANTAES="#undef ISC_PLATFORM_WANTAES"
if test "$with_aes" = "yes"
if test "$with_aes" = "yes"
ISC_PLATFORM_WANTAES="#define ISC_PLATFORM_WANTAES 1"
AC_SUBST(ISC_PLATFORM_WANTAES)
# Choose Client Cookie algorithm
AC_MSG_CHECKING(for the Algorithm for Client Cookie)
if test "$with_cc_alg" = "auto"
if test "$with_aes" = "yes"
if test "$CRYPTO" = "-DOPENSSL"
if test "$want_openssl_hash" = "checkcc"
AC_DEFINE(HMAC_SHA1_CC, 1,
[Use HMAC-SHA1 for Client Cookie generation])
if test "$CRYPTO" = "-DOPENSSL"
if test "$want_openssl_hash" = "checkcc"
AC_DEFINE(HMAC_SHA256_CC, 1,
[Use HMAC-SHA256 for Client Cookie generation])
if test "$with_aes" != "yes"
AC_MSG_ERROR("Client Cookie wants to use unavailable AES");
[Use AES for Client Cookie generation])
if test "$want_openssl_hash" = "checkcc"
# 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
if test "$CRYPTO" != "-DOPENSSL"
AC_MSG_ERROR([No OpenSSL for hash functions])
ISC_PLATFORM_OPENSSLHASH="#define ISC_PLATFORM_OPENSSLHASH 1"
ISC_OPENSSL_INC="$DST_OPENSSL_INC"
ISC_OPENSSL_LIBS="$DST_OPENSSL_LIBS"
CFLAGS="$CFLAGS $ISC_OPENSSL_INC"
LIBS="$LIBS $ISC_OPENSSL_LIBS"
AC_MSG_CHECKING([HMAC_Init() return type])
int n = HMAC_Init(&ctx, NULL, 0, NULL);
n += HMAC_Update(&ctx, NULL, 0);
n += HMAC_Final(&ctx, NULL, NULL);],[
AC_DEFINE(HMAC_RETURN_INT, 1, [HMAC_*() return ints])],[
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 "$use_pkcs11" = "auto"
if test "$want_native_pkcs11" = "yes"
AC_MSG_ERROR([PKCS11 requires thread support])
if test "$CRYPTO" = "-DOPENSSL"
AC_MSG_CHECKING(for OpenSSL with PKCS11 support)
CFLAGS="$CFLAGS $DST_OPENSSL_INC"
LIBS="$LIBS $DST_OPENSSL_LIBS"
e = ENGINE_by_id("pkcs11");
PKCS11_ENGINE='-DPKCS11_ENGINE="\"pkcs11\""'],
PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'],
[AC_MSG_RESULT(cross compile, defaulting to no)
PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'])
PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'
USE_PKCS11='-DUSE_PKCS11'
AC_CHECK_FUNC(getpassphrase, AC_DEFINE(HAVE_GETPASSPHRASE),)
ISC_PK11_API_O="pk11_api.$O"
ISC_PK11_RESULT_O="pk11_result.$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)
PKCS11_PROVIDER="undefined"
PKCS11_PROVIDER="undefined"
PKCS11_PROVIDER="$use_pkcs11"
AC_MSG_RESULT([enabled, PKCS11 provider is $PKCS11_PROVIDER])
AC_SUBST(PKCS11_PROVIDER)
AC_MSG_CHECKING(for native PKCS11)
case "$want_native_pkcs11" in
AC_MSG_RESULT(using native PKCS11 crypto)
PKCS11LINKOBJS='${PKCS11LINKOBJS}'
PKCS11LINKSRCS='${PKCS11LINKSRCS}'
AC_MSG_CHECKING(for PKCS11 ECDSA)
AC_DEFINE(HAVE_PKCS11_ECDSA, 1,
[Define if your PKCS11 provider supports ECDSA.])
AC_MSG_CHECKING(for PKCS11 GOST)
AC_DEFINE(HAVE_PKCS11_GOST, 1,
[Define if your PKCS11 provider supports GOST.])
AC_CHECK_FUNC(clock_gettime,have_clock_gt=yes,)
if test "$have_clock_gt" = "no"; then
AC_CHECK_LIB(rt,clock_gettime,have_clock_gt=rt,)
if test "$have_clock_gt" != "no"; then
AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [Define if clock_gettime is available.])
if test "$have_clock_gt" = "rt"; then
# was --with-lmdb specified?
AC_MSG_CHECKING(for lmdb library)
[ --with-lmdb[=PATH] build with LMDB library [yes|no|path]],
use_lmdb="$withval", use_lmdb="auto")
lmdb_cflags="-I ${d}/include"
lmdb_cflags="-I${use_lmdb}/include"
LIBS="$LIBS -L${use_lmdb}/lib"
if test "X${have_lmdb}" != "X"
AC_SEARCH_LIBS([mdb_env_create], [lmdb], [],
[AC_MSG_ERROR([found lmdb include but not library.])
elif test "X$use_lmdb" = Xyes
if test "X${have_lmdb}" != "X"
CFLAGS="$CFLAGS $lmdb_cflags"
AC_DEFINE(HAVE_LMDB, 1, [Define if lmdb was found])
NZDTARGETS='${NZDTARGETS}'
# was --with-libxml2 specified?
AC_MSG_CHECKING(for libxml2 library)
[ --with-libxml2[=PATH] build with libxml2 library [yes|no|path]],
use_libxml2="$withval", use_libxml2="auto")
case X`(xml2-config --version) 2>
/dev/null` in
libxml2_libs=`xml2-config --libs`
libxml2_cflags=`xml2-config --cflags`
if test "$use_libxml2" = "yes" ; then
AC_MSG_ERROR(required libxml2 version not available)
if test "X$libxml2_libs" != "X"
CFLAGS="$CFLAGS $libxml2_cflags"
LIBS="$LIBS $libxml2_libs"
# Sanity check xml2-config output.
[return(xmlTextWriterStartElement(NULL, NULL));],
AC_MSG_ERROR(xml2-config returns badness))
AC_DEFINE(HAVE_LIBXML2, 1, [Define if libxml2 was found])
# was --with-libjson specified?
AC_MSG_CHECKING(for json library)
[ --with-libjson[=PATH] build with libjson0 library [yes|no|path]],
use_libjson="$withval", use_libjson="auto")
libjson_cflags="-I ${d}/include"
libjson_cflags="-I ${d}/include"
libjson_cflags="-I${use_libjson}/include"
LIBS="$LIBS -L${use_libjson}/lib"
libjson_cflags="-I${use_libjson}/include"
LIBS="$LIBS -L${use_libjson}/lib"
if test "X${have_libjson}" != "X"
AC_SEARCH_LIBS([json_object_new_int64], [json json-c], [],
[AC_MSG_ERROR([found libjson include but not library.])
elif test "X$use_libjson" = Xyes
if test "X${have_libjson}" != "X"
CFLAGS="$CFLAGS $libjson_cflags"
AC_DEFINE(HAVE_JSON, 1, [Define if libjson was found])
if test "X${have_libjson_c}" = Xyes
AC_DEFINE(HAVE_JSON_C, 1, [Define if json-c was found])
# was --with-zlib specified?
AC_MSG_CHECKING(for zlib library)
[ --with-zlib[=PATH] build with zlib for HTTP compression [[default=yes]] ],
with_zlib="$withval", with_zlib="auto")
zlib_cflags="-I ${d}/include"
if test -f "${with_zlib}/
zlib.h"
zlib_cflags="-I${with_zlib}/include"
LIBS="$LIBS -L${with_zlib}/lib"
if test "X${have_zlib}" != "X"
AC_SEARCH_LIBS([deflate], [z], [],
[AC_MSG_ERROR([found zlib include but not library.])
elif test "X$with_zlib" = Xyes
if test "X${have_zlib}" != "X"
CFLAGS="$CFLAGS $zlib_cflags"
AC_DEFINE(HAVE_ZLIB, 1, [Define if zlib was found])
# 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
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)
AC_ARG_ENABLE(largefile, [ --enable-largefile 64-bit file support],
want_largefile="yes", want_largefile="no")
ALWAYS_DEFINES="$ALWAYS_DEFINES -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
# Additional compiler settings.
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)
CFLAGS="$CFLAGS -Werror -fno-strict-aliasing"
AC_TRY_COMPILE(,, [FNOSTRICTALIASING=yes],[FNOSTRICTALIASING=no])
if test "$FNOSTRICTALIASING" = "yes"; then
STD_CWARNINGS="$STD_CWARNINGS -fno-strict-aliasing"
# turn off delete null pointer checks
AC_MSG_CHECKING(if "$CC" supports -fno-delete-null-pointer-checks)
CFLAGS="$CFLAGS -Werror -fno-delete-null-pointer-checks"
AC_TRY_COMPILE(,, [FNODELETENULLPOINTERCHECKS=yes],
[FNODELETENULLPOINTERCHECKS=no])
if test "$FNODELETENULLPOINTERCHECKS" = "yes"; then
STD_CWARNINGS="$STD_CWARNINGS -fno-delete-null-pointer-checks"
CFLAGS="$CFLAGS -Wl,+vnocompatwarnings"
BACKTRACECFLAGS="$BACKTRACECFLAGS -Wl,+vnocompatwarnings"
if test "X$enable_warn_shadow" = Xyes; then
STD_CWARNINGS="$STD_CWARNINGS -Wshadow"
if test "X$enable_warn_error" = Xyes; then
STD_CWARNINGS="$STD_CWARNINGS -Werror"
# 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
# Turn off the pointlessly noisy warnings.
STD_CWARNINGS="+w1 +W 474,530,2193,2236"
CCNOOPT="$CCNOOPT -Ae -z"
CFLAGS="$CFLAGS -Wl,+vnocompatwarnings"
BACKTRACECFLAGS="$BACKTRACECFLAGS -Wl,+vnocompatwarnings"
MKDEPPROG='cc -Ae -E -Wp,-M >
/dev/null 2>>$TMP'
STD_CWARNINGS="-fullwarn -woff 1209"
# Silence more than 250 instances of
# "prototyped function redeclared without prototype"
# "variable ... was set but never used"
IRIX_DNSSEC_WARNINGS_HACK="-woff 1692,1552"
*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
AC_SUBST(IRIX_DNSSEC_WARNINGS_HACK)
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:
AC_CHECK_LIB(socket, socket)
AC_CHECK_LIB(nsl, inet_addr)
# Work around Solaris's select() limitations.
*-solaris2.[[89]]|*-solaris2.1?)
AC_DEFINE(FD_SETSIZE, 65536,
[Solaris hack to get select_large_fdset.])
AC_MSG_CHECKING(whether to use purify)
[ --with-purify[=PATH] use Rational purify],
use_purify="$withval", use_purify="no")
AC_PATH_PROG(purify_path, purify, purify)
purify_path="$use_purify"
if test -f $purify_path || test $purify_path = purify; then
AC_MSG_RESULT($purify_path)
PURIFYFLAGS="`echo $PURIFYOPTIONS`"
PURIFY="$purify_path $PURIFYFLAGS"
AC_MSG_ERROR([$purify_path not found.
Please choose the proper path with the following command:
configure --with-purify=PATH
AC_MSG_CHECKING(whether to use gperftools profiler)
AC_ARG_WITH(gperftools-profiler,
[ --with-gperftools-profiler use gperftools CPU profiler],
use_profiler="$withval", use_profiler="no")
AC_DEFINE([HAVE_GPERFTOOLS_PROFILER], 1,
[Define to use gperftools CPU profiler.])
#
enable/disable dumping stack backtrace. Also check if the system supports
# glibc-compatible backtrace() function.
[ --enable-backtrace log stack backtrace on abort [[default=yes]]],
want_backtrace="$enableval", want_backtrace="yes")
ISC_PLATFORM_USEBACKTRACE="#define ISC_PLATFORM_USEBACKTRACE 1"
[return (backtrace((void **)0, 0));],
[AC_DEFINE([HAVE_LIBCTRACE], [], [if system have backtrace function])],)
ISC_PLATFORM_USEBACKTRACE="#undef ISC_PLATFORM_USEBACKTRACE"
AC_SUBST(ISC_PLATFORM_USEBACKTRACE)
[ --enable-symtable use internal symbol table for backtrace
[[all|minimal(default)|none]]],
want_symtable="$enableval", want_symtable="minimal")
yes|all|minimal) # "yes" is a hidden value equivalent to "minimal"
AC_MSG_ERROR([Internal symbol table requires perl but no perl is found.
Install perl or explicitly disable the feature by --disable-symtable.])
if test "$use_libtool" = "yes"; then
AC_MSG_WARN([Internal symbol table does not work with libtool. Disabling symbol table.])
# 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
freebsd*|netbsd*|openbsd*|linux*|solaris*|darwin*)
if test $want_symtable = all; then
ALWAYS_MAKE_SYMTABLE="yes"
if test $want_symtable = yes -o $want_symtable = all
AC_MSG_WARN([this system is not known to generate internal symbol table safely; disabling it])
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.
AC_SUBST(LIBTOOL_MKDEP_SED)
AC_SUBST(LIBTOOL_MODE_COMPILE)
AC_SUBST(LIBTOOL_MODE_INSTALL)
AC_SUBST(LIBTOOL_MODE_LINK)
AC_SUBST(LIBTOOL_ALLOW_UNDEFINED)
AC_SUBST(LIBTOOL_IN_MAIN)
# Here begins a very long section to determine the system's networking
# capabilities. The order of the tests is significant.
[ --enable-ipv6 use IPv6 [default=autodetect]])
# 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)
[struct sockaddr_in6 sin6; return (0);],
# 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)
[ --with-kame[=PATH] use Kame IPv6 [default path
/usr/local/v6]],
use_kame="$withval", use_kame="no")
Please choose the proper path with the following command:
configure --with-kame=PATH
# 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
ISC_PLATFORM_NEEDNETINET6IN6H="#define ISC_PLATFORM_NEEDNETINET6IN6H 1"
LWRES_PLATFORM_NEEDNETINET6IN6H="#define LWRES_PLATFORM_NEEDNETINET6IN6H 1"
ISC_PLATFORM_NEEDNETINET6IN6H="#undef ISC_PLATFORM_NEEDNETINET6IN6H"
LWRES_PLATFORM_NEEDNETINET6IN6H="#undef LWRES_PLATFORM_NEEDNETINET6IN6H"
*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
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_PLATFORM_NEEDNETINETIN6H="#undef ISC_PLATFORM_NEEDNETINETIN6H"
LWRES_PLATFORM_NEEDNETINETIN6H="#undef LWRES_PLATFORM_NEEDNETINETIN6H"
ISC_PLATFORM_FIXIN6ISADDR="#undef ISC_PLATFORM_FIXIN6ISADDR"
# Now delve deeper into the suitability of the IPv6 support.
ISC_PLATFORM_HAVEIPV6="#define ISC_PLATFORM_HAVEIPV6 1"
LWRES_PLATFORM_HAVEIPV6="#define LWRES_PLATFORM_HAVEIPV6 1"
AC_MSG_CHECKING(for in6_addr)
[struct in6_addr in6; return (0);],
ISC_PLATFORM_HAVEINADDR6="#undef ISC_PLATFORM_HAVEINADDR6"
LWRES_PLATFORM_HAVEINADDR6="#undef LWRES_PLATFORM_HAVEINADDR6"
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)
[struct in6_addr in6; in6 = in6addr_any; return (
in6.s6_addr[0]);],
ISC_PLATFORM_NEEDIN6ADDRANY="#undef ISC_PLATFORM_NEEDIN6ADDRANY"
LWRES_PLATFORM_NEEDIN6ADDRANY="#undef LWRES_PLATFORM_NEEDIN6ADDRANY"],
ISC_PLATFORM_NEEDIN6ADDRANY="#define ISC_PLATFORM_NEEDIN6ADDRANY 1"
LWRES_PLATFORM_NEEDIN6ADDRANY="#define LWRES_PLATFORM_NEEDIN6ADDRANY 1"])
AC_MSG_CHECKING(for in6addr_loopback)
[struct in6_addr in6; in6 = in6addr_loopback; return (
in6.s6_addr[0]);],
ISC_PLATFORM_NEEDIN6ADDRLOOPBACK="#undef ISC_PLATFORM_NEEDIN6ADDRLOOPBACK"
LWRES_PLATFORM_NEEDIN6ADDRLOOPBACK="#undef LWRES_PLATFORM_NEEDIN6ADDRLOOPBACK"],
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)
ISC_PLATFORM_HAVESCOPEID="#define ISC_PLATFORM_HAVESCOPEID 1"
result="#define LWRES_HAVE_SIN6_SCOPE_ID 1"],
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)
[struct in6_pktinfo xyzzy; return (0);],
ISC_PLATFORM_HAVEIN6PKTINFO="#define ISC_PLATFORM_HAVEIN6PKTINFO 1"],
[AC_MSG_RESULT(no -- disabling runtime ipv6 support)
ISC_PLATFORM_HAVEIN6PKTINFO="#undef ISC_PLATFORM_HAVEIN6PKTINFO"])
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"
AC_MSG_CHECKING(for struct sockaddr_storage)
[struct sockaddr_storage storage; return (0);],
ISC_PLATFORM_HAVESOCKADDRSTORAGE="#define ISC_PLATFORM_HAVESOCKADDRSTORAGE 1"],
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(LWRES_HAVE_SIN6_SCOPE_ID)
AC_SUBST(ISC_PLATFORM_HAVESCOPEID)
AC_MSG_CHECKING([for struct if_laddrreq])
],[ struct if_laddrreq a; ],
ISC_PLATFORM_HAVEIF_LADDRREQ="#define ISC_PLATFORM_HAVEIF_LADDRREQ 1"],
ISC_PLATFORM_HAVEIF_LADDRREQ="#undef ISC_PLATFORM_HAVEIF_LADDRREQ"])
AC_SUBST(ISC_PLATFORM_HAVEIF_LADDRREQ)
AC_MSG_CHECKING([for struct if_laddrconf])
],[ struct if_laddrconf a; ],
ISC_PLATFORM_HAVEIF_LADDRCONF="#define ISC_PLATFORM_HAVEIF_LADDRCONF 1"],
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])
char a[16],b[64]; return(inet_ntop(AF_INET6, a, b, sizeof(b)) == (char*)0);}],
ISC_PLATFORM_NEEDNTOP="#undef ISC_PLATFORM_NEEDNTOP"],
ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS inet_ntop.$O"
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])
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)); }],
ISC_PLATFORM_NEEDPTON="#undef ISC_PLATFORM_NEEDPTON"],
ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS inet_pton.$O"
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_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.
# Turn on 4.4BSD style sa_len support.
AC_MSG_CHECKING(for sa_len in struct sockaddr)
[struct sockaddr sa;
sa.sa_len = 0; return (0);],
ISC_PLATFORM_HAVESALEN="#define ISC_PLATFORM_HAVESALEN 1"
LWRES_PLATFORM_HAVESALEN="#define LWRES_PLATFORM_HAVESALEN 1"],
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)
ISC_PLATFORM_MSGHDRFLAVOR="#define ISC_NET_BSD44MSGHDR 1"],
ISC_PLATFORM_MSGHDRFLAVOR="#define ISC_NET_BSD43MSGHDR 1"])
AC_SUBST(ISC_PLATFORM_MSGHDRFLAVOR)
AC_MSG_CHECKING(for type in_port_t)
[in_port_t port = 25; return (0);],
ISC_PLATFORM_NEEDPORTT="#undef ISC_PLATFORM_NEEDPORTT"],
ISC_PLATFORM_NEEDPORTT="#define ISC_PLATFORM_NEEDPORTT 1"])
AC_SUBST(ISC_PLATFORM_NEEDPORTT)
AC_MSG_CHECKING(for struct addrinfo)
[struct addrinfo a; return (0);],
ISC_LWRES_NEEDADDRINFO="#undef ISC_LWRES_NEEDADDRINFO"
ISC_IRS_NEEDADDRINFO="#undef ISC_IRS_NEEDADDRINFO"
AC_DEFINE(HAVE_ADDRINFO)],
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)
AC_MSG_CHECKING(for struct rrsetinfo)
[struct rrsetinfo r; return (0);],
ISC_LWRES_NEEDRRSETINFO="#undef ISC_LWRES_NEEDRRSETINFO"],
ISC_LWRES_NEEDRRSETINFO="#define ISC_LWRES_NEEDRRSETINFO 1"])
AC_SUBST(ISC_LWRES_NEEDRRSETINFO)
AC_MSG_CHECKING(for int sethostent)
[int i = sethostent(0); return(0);],
ISC_LWRES_SETHOSTENTINT="#define ISC_LWRES_SETHOSTENTINT 1"],
ISC_LWRES_SETHOSTENTINT="#undef ISC_LWRES_SETHOSTENTINT"])
AC_SUBST(ISC_LWRES_SETHOSTENTINT)
AC_MSG_CHECKING(for int endhostent)
[int i = endhostent(); return(0);],
ISC_LWRES_ENDHOSTENTINT="#define ISC_LWRES_ENDHOSTENTINT 1"],
ISC_LWRES_ENDHOSTENTINT="#undef ISC_LWRES_ENDHOSTENTINT"])
AC_SUBST(ISC_LWRES_ENDHOSTENTINT)
AC_MSG_CHECKING(for getnetbyaddr(in_addr_t, ...))
struct netent *getnetbyaddr(in_addr_t, int);],
ISC_LWRES_GETNETBYADDRINADDR="#define ISC_LWRES_GETNETBYADDRINADDR 1"],
ISC_LWRES_GETNETBYADDRINADDR="#undef ISC_LWRES_GETNETBYADDRINADDR"])
AC_SUBST(ISC_LWRES_GETNETBYADDRINADDR)
AC_MSG_CHECKING(for int setnetent)
[int i = setnetent(0); return(0);],
ISC_LWRES_SETNETENTINT="#define ISC_LWRES_SETNETENTINT 1"],
ISC_LWRES_SETNETENTINT="#undef ISC_LWRES_SETNETENTINT"])
AC_SUBST(ISC_LWRES_SETNETENTINT)
AC_MSG_CHECKING(for int endnetent)
[int i = endnetent(); return(0);],
ISC_LWRES_ENDNETENTINT="#define ISC_LWRES_ENDNETENTINT 1"],
ISC_LWRES_ENDNETENTINT="#undef ISC_LWRES_ENDNETENTINT"])
AC_SUBST(ISC_LWRES_ENDNETENTINT)
AC_MSG_CHECKING(for gethostbyaddr(const void *, size_t, ...))
struct hostent *gethostbyaddr(const void *, size_t, int);],
ISC_LWRES_GETHOSTBYADDRVOID="#define ISC_LWRES_GETHOSTBYADDRVOID 1"],
ISC_LWRES_GETHOSTBYADDRVOID="#undef ISC_LWRES_GETHOSTBYADDRVOID"])
AC_SUBST(ISC_LWRES_GETHOSTBYADDRVOID)
AC_MSG_CHECKING(for h_errno in
netdb.h)
[h_errno = 1; return(0);],
ISC_LWRES_NEEDHERRNO="#undef ISC_LWRES_NEEDHERRNO"],
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
AC_MSG_CHECKING(for getnameinfo prototype definitions)
int getnameinfo(const struct sockaddr *, socklen_t, char *,
socklen_t, char *, socklen_t, unsigned int);],
[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).])],
int getnameinfo(const struct sockaddr *, socklen_t, char *,
size_t, char *, size_t, int);],
[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)],
int getnameinfo(const struct sockaddr *, size_t, char *,
size_t, char *, size_t, int);],
[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)
char *gai_strerror(int ecode);],
[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,
[ --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
AC_MSG_WARN("--enable-getifaddrs=glibc is no longer required")
AC_CHECK_FUNC(getifaddrs, AC_DEFINE(HAVE_GETIFADDRS))
AC_CHECK_FUNC(getifaddrs, AC_DEFINE(HAVE_GETIFADDRS))
# Look for a sysctl call to get the list of network interfaces.
case $ac_cv_header_sys_sysctl_h in
AC_MSG_CHECKING(for interface list sysctl)
AC_EGREP_CPP(found_rt_iflist, [
AC_DEFINE(HAVE_IFLIST_SYSCTL)],
# Check for some other useful functions that are not ever-present.
# We test for strsep() using AC_TRY_LINK instead of AC_CHECK_FUNC
# 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
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)
[ISC_PLATFORM_NEEDMEMMOVE="#undef ISC_PLATFORM_NEEDMEMMOVE"],
[ISC_PLATFORM_NEEDMEMMOVE="#define ISC_PLATFORM_NEEDMEMMOVE 1"])
AC_SUBST(ISC_PLATFORM_NEEDMEMMOVE)
[ISC_PLATFORM_NEEDSTRTOUL="#undef ISC_PLATFORM_NEEDSTRTOUL"
LWRES_PLATFORM_NEEDSTRTOUL="#undef LWRES_PLATFORM_NEEDSTRTOUL"
[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)
[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)
[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)
[ --with-readline[=LIBSPEC] specify readline library [default auto]],
readline="$withval", readline="auto")
for readline in -ledit -lreadline
AC_MSG_NOTICE(checking for readline with $readline)
if test "$ac_cv_func_readline" = "yes"
for lib in -lterminfo -ltermcap -lncurses -lcurses
AC_MSG_NOTICE(checking for readline with $readline $lib)
unset ac_cv_func_readline
if test "$ac_cv_func_readline" = "yes"
READLINE_LIB="$readline $lib"
if test "$ac_cv_func_readline" = "yes"
AC_MSG_NOTICE(checking for readline with $readline)
if test "$ac_cv_func_readline" = "yes"
for lib in -lterminfo -ltermcap -lncurses -lcurses
AC_MSG_NOTICE(checking for readline with $readline $lib)
unset ac_cv_func_readline
if test "$ac_cv_func_readline" = "yes"
READLINE_LIB="$readline $lib"
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)
[ char buf[2]; return(*sprintf(buf,"x"));],
ISC_PRINT_OBJS="print.$O"
ISC_PLATFORM_NEEDSPRINTF="#define ISC_PLATFORM_NEEDSPRINTF"
LWRES_PLATFORM_NEEDSPRINTF="#define LWRES_PLATFORM_NEEDSPRINTF"
AC_CHECK_FUNC(vsnprintf, [],
[ISC_PRINT_OBJS="print.$O"
ISC_PLATFORM_NEEDVSNPRINTF="#define ISC_PLATFORM_NEEDVSNPRINTF 1"
LWRES_PLATFORM_NEEDVSNPRINTF="#define LWRES_PLATFORM_NEEDVSNPRINTF 1"])
AC_MSG_CHECKING(printf for %z support)
exit(strcmp(buf, "0") != 0);
ISC_PRINT_OBJS="print.$O"
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_CHECK_FUNC(strerror, AC_DEFINE(HAVE_STRERROR))
# Use our own SPNEGO implementation?
AC_ARG_ENABLE(isc-spnego,
[ --disable-isc-spnego use SPNEGO from GSSAPI library])
case "$enable_isc_spnego" in
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)
AC_MSG_RESULT(using SPNEGO from GSSAPI library)
# Determine the printf format characters to use when printing
# values of type isc_int64_t. This will normally be "ll", but where
# the compiler treats "long long" as a alias for "long" and printf
# doesn't know about "long long" use "l". Hopefully the sprintf
# will produce a inconsistent result in the later case. If the compiler
# fails due to seeing "%lld" we fall back to "l".
# Digital Unix 4.0 (gcc?) (long long) is 64 bits as is its long. It uses
# %ld even for (long long)/
# Win32 uses "%I64d", but that's defined elsewhere since we don't use
AC_MSG_CHECKING(printf format modifier for 64-bit integers)
exit((sizeof(long long int) != sizeof(long int))? 0 :
(strcmp(buf, "0") != 0));
ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "ll"'
LWRES_PLATFORM_QUADFORMAT='#define LWRES_PLATFORM_QUADFORMAT "ll"'],
ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "l"'
LWRES_PLATFORM_QUADFORMAT='#define LWRES_PLATFORM_QUADFORMAT "l"'],
[AC_MSG_RESULT(assuming target platform uses ll)
ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "ll"'
LWRES_PLATFORM_QUADFORMAT='#define LWRES_PLATFORM_QUADFORMAT "ll"'])
AC_SUBST(ISC_PLATFORM_QUADFORMAT)
AC_SUBST(LWRES_PLATFORM_QUADFORMAT)
# Note it is very recommended to *not* disable chroot(),
# this is only because chroot() was made obsolete by Posix.
[ --disable-chroot disable chroot])
AC_ARG_ENABLE(linux-caps,
[ --disable-linux-caps disable linux capabilities])
case "$enable_linux_caps" in
[#ifdef HAVE_LINUX_TYPES_H
AC_CHECK_LIB(cap, cap_set_proc)
ISC_PLATFORM_HAVESYSUNH="#define ISC_PLATFORM_HAVESYSUNH 1"
ISC_PLATFORM_HAVESYSUNH="#undef ISC_PLATFORM_HAVESYSUNH"
AC_SUBST(ISC_PLATFORM_HAVESYSUNH)
AC_DEFINE(NEED_SECURE_DIRECTORY, 1,
[Define if connect does not honour the permission on the UNIX domain socket.])
AC_DEFINE(NEED_SECURE_DIRECTORY, 1,
[Define if connect does not honour the permission on the UNIX domain socket.])
AC_CHECK_FUNC(tzset, AC_DEFINE(HAVE_TZSET))
AC_MSG_CHECKING(for optarg declaration)
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
ISC_PLATFORM_HAVESTATNSEC="#define ISC_PLATFORM_HAVESTATNSEC 1"],
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)
[rlim_t rl = 19671212; return (0);],
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE rlim_t"],
AC_MSG_CHECKING(type of rlim_cur)
main() { struct rlimit r; exit(!(sizeof(
r.rlim_cur) == sizeof(int)));}],
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE int"],
main() { struct rlimit r; exit(!(sizeof(
r.rlim_cur) == sizeof(long int)));}],
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE long int"],
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
# Compaq TruCluster requires more code for handling cluster IP aliases
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]))
# 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().
AC_DEFINE(BROKEN_RECVMSG, 1,
[Define if recvmsg() does not meet all of the BSD socket API specifications.])
# 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"
hack_shutup_pthreadonceinit=yes
hack_shutup_stdargcast=yes
hack_shutup_pthreadonceinit=yes
AC_TRY_COMPILE([ #include <
pthread.h> ], [ static pthread_once_t once_test = { PTHREAD_ONCE_INIT }; ], [hack_shutup_pthreadonceinit=yes], )
case "$hack_shutup_pthreadonceinit" in
# Shut up PTHREAD_ONCE_INIT unbraced initializer warnings.
ISC_PLATFORM_BRACEPTHREADONCEINIT="#define ISC_PLATFORM_BRACEPTHREADONCEINIT 1"
case "$hack_shutup_sigwait" in
# Shut up a -Wmissing-prototypes warning for sigwait().
AC_DEFINE(SHUTUP_SIGWAIT)
case "$hack_shutup_sputaux" in
# Shut up a -Wmissing-prototypes warning from <
stdio.h>.
AC_DEFINE(SHUTUP_SPUTAUX)
case "$hack_shutup_stdargcast" in
# Shut up a -Wcast-qual warning from va_start().
AC_DEFINE(SHUTUP_STDARG_CAST)
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
AC_CHECK_LIB(ipv6, if_nametoindex,
ac_cv_have_if_nametoindex=yes
case $ac_cv_have_if_nametoindex in
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"
AC_SUBST(ISC_PLATFORM_HAVEIFNAMETOINDEX)
AC_CHECK_FUNCS(nanosleep usleep)
# Machine architecture dependent features
[ --enable-atomic enable machine specific atomic operations
enable_atomic="$enableval",
enable_atomic="autodetect")
if test "X$GCC" = "Xyes"; then
AC_MSG_CHECKING([if asm("isc"); works])
main() { asm("ics"); exit(0); }
CFLAGS="$CFLAGS -Wa,-many"
main() { asm("ics"); exit(0); }
[AC_MSG_RESULT([yes, required -Wa,-many])
[AC_MSG_RESULT([no, use_atomic disabled])
[AC_MSG_RESULT([cross compile, assume yes])
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 "$use_atomic" = "yes"; then
have_atomic=yes # set default
# 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
AC_CHECK_SIZEOF([void *])
if test $ac_cv_sizeof_void_p = 8; then
mips-*|mipsel-*|mips64-*|mips64el-*)
AC_MSG_CHECKING([architecture type for atomic operations])
if test "$have_atomic" = "yes"; then
AC_MSG_CHECKING([compiler support for inline assembly code])
# Check whether the compiler supports the assembly syntax we provide.
if test "X$GCC" = "Xyes"; then
# GCC's ASM extension always works
if test $arch = "x86_64"; then
# We can share the same code for gcc with x86_32
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])
__asm__ volatile ("li r0, 0x0\n"::);
ISC_PLATFORM_USEMACASM="#define ISC_PLATFORM_USEMACASM 1"
# Tru64 compiler has its own syntax for inline
#error "unexpected compiler"
ISC_PLATFORM_USEGCCASM="#define ISC_PLATFORM_USEGCCASM 1"
ISC_PLATFORM_USEOSFASM="#define ISC_PLATFORM_USEOSFASM 1"
# See if the generic __asm function works. If not,
# we need to disable the atomic operations.
ISC_PLATFORM_USESTDASM="#define ISC_PLATFORM_USESTDASM 1"],
[compiler="not supported (atomic operations disabled)"
if test "$have_atomic" = "yes"; 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 "$have_xaddq" = "yes"; then
ISC_PLATFORM_HAVEXADDQ="#define ISC_PLATFORM_HAVEXADDQ 1"
ISC_PLATFORM_HAVEATOMICSTOREQ="#define ISC_PLATFORM_HAVEATOMICSTOREQ 1"
ISC_PLATFORM_HAVEXADDQ="#undef ISC_PLATFORM_HAVEXADDQ"
ISC_PLATFORM_HAVEATOMICSTOREQ="#undef ISC_PLATFORM_HAVEATOMICSTOREQ"
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"
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)
# Check for __builtin_expect
AC_MSG_CHECKING([compiler support for __builtin_expect])
return (__builtin_expect(1, 1) ? 1 : 0);
if test "$have_builtin_expect" = "yes"; then
AC_DEFINE(HAVE_BUILTIN_EXPECT, 1, [Define to 1 if the compiler supports __builtin_expect.])
# Check for __builtin_clz
AC_MSG_CHECKING([compiler support for __builtin_clz])
return (__builtin_clz(0xff) == 24 ? 1 : 0);
if test "$have_builtin_clz" = "yes"; then
AC_DEFINE(HAVE_BUILTIN_CLZ, 1, [Define to 1 if the compiler supports __builtin_clz.])
# CPU relax (for spin locks)
AC_MSG_CHECKING([if asm("rep; nop"); works])
AC_TRY_COMPILE(,[asm("rep; nop");],
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
[AC_MSG_RESULT([cross compile, assume yes])
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
AC_MSG_CHECKING([if asm("rep; nop"); works])
AC_TRY_COMPILE(,[asm("rep; nop");],
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
[AC_MSG_RESULT([cross compile, assume yes])
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
AC_MSG_CHECKING([if asm("hint @pause"); works])
AC_TRY_COMPILE(,[asm("hint @pause");],
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"],
[AC_MSG_RESULT([cross compile, assume yes])
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"])
AC_MSG_CHECKING([if cpu_relax(); or __cpu_relax(); works])
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP cpu_relax()"],
[AC_CHECK_FUNC(__cpu_relax,
ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP __cpu_relax()"],
AC_SUBST(ISC_PLATFORM_BUSYWAITNOP)
# Activate "rrset-order fixed" or not?
AC_ARG_ENABLE(fixed-rrset,
[ --enable-fixed-rrset enable fixed rrset ordering [[default=no]]],
enable_fixed="$enableval",
AC_DEFINE(DNS_RDATASET_FIXED, 1,
[Define to enable "rrset-order fixed" syntax.])
# Enable response policy rewriting using NS IP addresses
[ --disable-rpz-nsip disable rpz-nsip rules [[default=enabled]]],
enable_nsip="$enableval",
AC_DEFINE(ENABLE_RPZ_NSIP, 1,
[Define to enable rpz-nsip rules.])
# Enable response policy rewriting using NS name
AC_ARG_ENABLE(rpz-nsdname,
[ --disable-rpz-nsdname disable rpz-nsdname rules [[default=enabled]]],
enable_nsdname="$enableval",
case "$enable_nsdname" in
AC_DEFINE(ENABLE_RPZ_NSDNAME, 1,
[Define to enable rpz-nsdname rules.])
AC_ARG_ENABLE(filter-aaaa,
[ --enable-filter-aaaa enable filtering of AAAA records [[default=no]]],
enable_filter="$enableval",
AC_DEFINE(ALLOW_FILTER_AAAA, 1,
[Define to enable the "filter-aaaa-on-v4" and "filter-aaaa-on-v6" options.])
[ --enable-dnstap enable dnstap support (requires fstrm, protobuf-c)],
if test "x$use_dnstap" != "xno"; then
AC_MSG_ERROR([Dnstap requires threads.])
AC_PATH_PROG([PROTOC_C], [protoc-c])
if test -z "$PROTOC_C"; then
AC_MSG_ERROR([The protoc-c program was not found.])
AC_ARG_WITH([protobuf-c],
AC_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
# workaround for protobuf-c includes at old dir
# before protobuf-c-1.0.0
AC_ARG_WITH([libfstrm], AC_HELP_STRING([--with-libfstrm=path],
[Path where libfstrm is installed, for dnstap]), [
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])
DNSTAPSRCS='${DNSTAPSRCS}'
DNSTAPOBJS='${DNSTAPOBJS}'
DNSTAPTARGETS='${DNSTAPTARGETS}'
# The following sets up how non-blocking i/o is established.
# Sunos, cygwin and solaris
2.x (x<5) require special handling.
*-sunos*) AC_DEFINE(PORT_NONBLOCK, O_NDELAY);;
*-cygwin*) AC_DEFINE(PORT_NONBLOCK, O_NDELAY);;
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,
# Solaris 2.5.1 and earlier cannot bind() then connect() a TCP socket.
# This prevents the source address being set.
*-solaris2.[[012345]]|*-solaris2.5.1)
AC_DEFINE(BROKEN_TCP_BIND_BEFORE_CONNECT, 1,
[Define if you cannot bind() before connect() for TCP sockets.])
# The following sections deal with tools used for formatting
# the documentation. They are all optional, unless you are
# a developer editing the documentation source.
AC_PATH_PROGS(LATEX, latex, latex)
AC_PATH_PROGS(PDFLATEX, pdflatex, pdflatex)
AC_PATH_PROGS(DBLATEX, dblatex, dblatex)
AC_PATH_PROGS(W3M, w3m, w3m)
# Look for xsltproc (libxslt)
AC_PATH_PROG(XSLTPROC, xsltproc, xsltproc)
# Look for xmllint (libxml2)
AC_PATH_PROG(XMLLINT, xmllint, xmllint)
AC_PATH_PROG(DOXYGEN, doxygen, doxygen)
AC_PATH_PROG(CURL, curl, 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, [
AC_MSG_RESULT("not found");
# 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
AC_MSG_CHECKING(for Docbook-XSL path)
[ --with-docbook-xsl=PATH specify path for Docbook-XSL stylesheets],
docbook_path="$withval", docbook_path="auto")
docbook_xsl_trees="$withval"
AC_MSG_RESULT($docbook_xsl_trees)
# Look for stylesheets we need.
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)
[ --with-idn[=MPREFIX] enable IDN support using idnkit [default PREFIX]],
use_idn="$withval", use_idn="no")
if test X$prefix = XNONE ; then
[ --with-libiconv[=IPREFIX] GNU libiconv are in IPREFIX [default PREFIX]],
use_libiconv="$withval", use_libiconv="no")
if test X$prefix = XNONE ; then
[ --with-iconv[=LIBSPEC] specify iconv library [default -liconv]],
[ --with-idnlib=ARG specify libidnkit],
idnlib="$withval", idnlib="no")
if test "$idnlib" = yes; then
AC_MSG_ERROR([You must specify ARG for --with-idnlib.])
if test "$use_idn" != no; then
AC_DEFINE(WITH_IDN, 1, [define if idnkit support is to be included.])
if test "$idnlib" != no; then
IDNLIBS="$idnlib $iconvlib"
# Check whether to build Automated Test Framework unit tests
[ --with-atf=ARG support Automated Test Framework],
atf="$withval", atf="no")
if test "$atf" = yes; then
AC_CONFIG_COMMANDS([atf-config],
*) srcdir="../../$srcdir";;
${SHELL} "${srcdir}${srcdir:+
/unit/atf-src/}./configure" --enable-tools --disable-shared MISSING=: --prefix $atfdir;
if test "$atf" != no; then
AC_DEFINE(ATF_TEST, 1, [define if ATF unit tests are to be built.])
AC_CHECK_LIB(m, exp, libm=yes, libm=no)
if test "$libm" = "yes"; then
AC_CHECK_FUNCS(setlocale)
# was --with-tuning specified?
[ --with-tuning=ARG Specify server tuning (large or default)],
use_tuning="$withval", use_tuning="no")
AC_MSG_ERROR([Large-system tuning requires threads.])
AC_DEFINE(TUNE_LARGE, 1, [Define to use large-system tuning.])
AC_MSG_RESULT(using large-system tuning)
AC_MSG_RESULT(using default tuning)
AC_MSG_ERROR([You must specify "large" or "default" for --with-tuning.])
# was --enable-querytrace specified?
AC_ARG_ENABLE(querytrace,
[ --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
AC_DEFINE(WANT_QUERYTRACE, 1, [Define to enable very verbose query trace logging.])
AC_MSG_ERROR("--enable-querytrace requires yes or no")
AC_SUBST(BIND9_TOP_BUILDDIR)
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=""
BIND9_ISCCC_BUILDINCLUDE=""
BIND9_ISCCFG_BUILDINCLUDE=""
BIND9_DNS_BUILDINCLUDE=""
BIND9_LWRES_BUILDINCLUDE=""
BIND9_BIND9_BUILDINCLUDE=""
BIND9_IRS_BUILDINCLUDE=""
AC_SUBST_FILE(BIND9_MAKE_INCLUDES)
AC_SUBST_FILE(BIND9_MAKE_RULES)
BIND9_PRODUCT="PRODUCT=\"${PRODUCT}\""
BIND9_DESCRIPTION="DESCRIPTION=\"${DESCRIPTION}\""
AC_SUBST(BIND9_DESCRIPTION)
BIND9_VERSION="${MAJORVER}.${MINORVER}${PATCHVER:+.}${PATCHVER}${RELEASETYPE}${RELEASEVER}${EXTENSIONS}"
BIND9_MAJOR="MAJOR=${MAJORVER}.${MINORVER}"
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"
if test -f "${srcdir}/srcid"; then
BIND9_SRCID="SRCID=$SRCID"
elif test -d "${srcdir}/.git"; then
BIND9_SRCID="SRCID="`(cd "${srcdir}";git rev-parse --short HEAD)`
if test -z "$ac_configure_args"; then
BIND9_CONFIGARGS="defaults"
for a in $ac_configure_args
BIND9_CONFIGARGS="$BIND9_CONFIGARGS $a"
BIND9_CONFIGARGS="`echo $BIND9_CONFIGARGS | sed 's/^ //'`"
BIND9_CONFIGARGS="CONFIGARGS=${BIND9_CONFIGARGS}"
AC_SUBST(BIND9_CONFIGARGS)
AC_SUBST_FILE(LIBISC_API)
AC_SUBST_FILE(LIBISCCC_API)
AC_SUBST_FILE(LIBISCCFG_API)
AC_SUBST_FILE(LIBDNS_API)
AC_SUBST_FILE(LIBDNS_MAPAPI)
AC_SUBST_FILE(LIBBIND9_API)
AC_SUBST_FILE(LIBLWRES_API)
AC_SUBST_FILE(LIBIRS_API)
# Configure any DLZ drivers.
# 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.
# 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
[ --with-dlopen=ARG support dynamically loadable DLZ drivers],
dlopen="$withval", dlopen="yes")
if test "$dlopen" = "yes"; then
AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
if test "$have_dl" = "yes"; then
AC_CHECK_FUNCS(dlopen dlclose dlsym,,dlopen=no)
if test "$dlopen" = "yes"; then
if test "$have_dl" = "yes"
if test "$use_libtool" = "yes"; then
SO_LDFLAGS="-Xcompiler -shared"
LDFLAGS="${LDFLAGS} -Wl,-E"
if test "$use_libtool" = "yes"; then
SO_LDFLAGS="-Xcompiler -shared"
SO_LDFLAGS="-Bshareable -x"
SO_LDFLAGS="-b +vnocompatwarnings"
if test "X$GCC" = "Xyes"; then
if test "$use_libtool" = "yes"; then
SO_LDFLAGS="-Xcompiler -shared"
# 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().])
CFLAGS="$CFLAGS $SO_CFLAGS"
AC_MSG_CHECKING(contributed DLZ drivers)
if test -n "$CONTRIB_DLZ"
AC_CONFIG_FILES([$DLZ_DRIVER_RULES])
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_FILE(DLZ_DRIVER_RULES)
if test "$cross_compiling" = "yes"; then
if test -z "$BUILD_CC"; then
AC_MSG_ERROR([BUILD_CC not set])
BUILD_CFLAGS="$BUILD_CFLAGS"
BUILD_CPPFLAGS="$BUILD_CPPFLAGS"
BUILD_LDFLAGS="$BUILD_LDFLAGS"
BUILD_CPPFLAGS="$CPPFLAGS $GEN_NEED_OPTARG"
for e in $BUILD_LDFLAGS ; do
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-R%'`
NEWFLAGS="$NEWFLAGS $e $ee"
BUILD_LDFLAGS="$NEWFLAGS"
for e in $DNS_GSSAPI_LIBS ; do
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-R%'`
NEWFLAGS="$NEWFLAGS $e $ee"
DNS_GSSAPI_LIBS="$NEWFLAGS"
for e in $ISC_OPENSSL_LIBS ; do
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-R%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ISC_OPENSSL_LIBS="$NEWFLAGS"
for e in $DNS_CRYPTO_LIBS ; do
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
NEWFLAGS="$NEWFLAGS $e $ee"
ee=`echo $e | sed -e 's%^-L%-R%'`
NEWFLAGS="$NEWFLAGS $e $ee"
DNS_CRYPTO_LIBS="$NEWFLAGS"
# Don't just put these into configure, it won't work right if somebody
# 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.
# Now that the Makefiles exist we can ensure that everything is rebuilt.
[ --with-make-clean run "make clean" at end of configure [[yes|no]]],
make_clean="$withval", make_clean="yes")
if test "$no_create" != "yes"
AC_ARG_ENABLE(full-report,
[ --enable-full-report report values of all configure options])
echo "==============================================================================="
echo "Configuration summary:"
echo "-------------------------------------------------------------------------------"
echo "Optional features enabled:"
echo " Multiprocessing support (--enable-threads)"
if test "$enable_full_report" = "yes" -o "$locktype" = "standard"; then
echo " Mutex lock type: $locktype"
test "$use_tuning" = "large" && echo " Large-system tuning (--with-tuning)"
test "$use_dnstap" = "no" || \
echo " Allow 'dnstap' packet logging (--enable-dnstap)"
test "$use_geoip" = "no" || echo " GeoIP access control (--with-geoip)"
test "$use_gssapi" = "no" || echo " GSS-API (--with-gssapi)"
if test "$enable_full_report" = "yes" -o "$with_cc_alg" != "aes"; then
echo " Algorithm: $with_cc_alg"
# these lines are only printed if run with --enable-full-report
if test "$enable_full_report" = "yes"; then
test "$enable_ipv6" = "no" -o "$found_ipv6" = "no" || \
echo " IPv6 support (--enable-ipv6)"
test "X$CRYPTO" = "X" -o "$want_native_pkcs11" = "yes" || \
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)"
if test "$use_pkcs11" != "no"; then
if test "$want_native_pkcs11" = "yes"; then
echo " Native PKCS#11/Cryptoki support (--enable-native-pkcs11)"
echo " PKCS#11/Cryptoki support using OpenSSL (--with-pkcs11)"
echo " Provider library: $PKCS11_PROVIDER"
if test "$OPENSSL_GOST" = "yes" -o "$PKCS11_GOST" = "yes"; then
echo " GOST algorithm support (encoding: $gosttype) (--with-gost)"
test "$OPENSSL_ECDSA" = "yes" -o "$PKCS11_ECDSA" = "yes" && \
echo " ECDSA algorithm support (--with-ecdsa)"
test "$enable_fixed" = "yes" && \
echo " Allow 'fixed' rrset-order (--enable-fixed-rrset)"
test "$enable_filter" = "yes" && \
echo " AAAA filtering (--enable-filter-aaaa)"
test "$enable_seccomp" = yes && \
echo " Use libseccomp system call filtering (--enable-seccomp)"
test "$want_backtrace" = "yes" && \
echo " Print backtrace on crash (--enable-backtrace)"
test "$want_symtable" = "minimal" && \
echo " Use symbol table for backtrace, named only (--enable-symtable)"
test "$want_symtable" = "yes" -o "$want_symtable" = "all" && \
echo " Use symbol table for backtrace, all binaries (--enable-symtable=all)"
test "$use_libtool" = "no" || echo " Use GNU libtool (--with-libtool)"
test "$want_querytrace" = "yes" && \
echo " Very verbose query trace logging (--enable-querytrace)"
test "$atf" = "no" || echo " Automated Testing Framework (--with-atf)"
echo " Dynamically loadable zone (DLZ) drivers:"
test "$use_dlz_bdb" = "no" || \
echo " Berkeley DB (--with-dlz-bdb)"
test "$use_dlz_ldap" = "no" || \
echo " LDAP (--with-dlz-ldap)"
test "$use_dlz_mysql" = "no" || \
echo " MySQL (--with-dlz-mysql)"
test "$use_dlz_odbc" = "no" || \
echo " ODBC (--with-dlz-odbc)"
test "$use_dlz_postgres" = "no" || \
echo " Postgres (--with-dlz-postgres)"
test "$use_dlz_filesystem" = "no" || \
echo " Filesystem (--with-dlz-filesystem)"
test "$use_dlz_stub" = "no" || \
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 "Features disabled or unavailable on this platform:"
$use_threads || echo " Multiprocessing support (--enable-threads)"
test "$enable_ipv6" = "no" -o "$found_ipv6" = "no" && \
echo " IPv6 support (--enable-ipv6)"
test "$use_tuning" = "large" || echo " Large-system tuning (--with-tuning)"
test "$use_dnstap" = "no" && \
echo " Allow 'dnstap' packet logging (--enable-dnstap)"
test "$use_geoip" = "no" && echo " GeoIP access control (--with-geoip)"
test "$use_gssapi" = "no" && echo " GSS-API (--with-gssapi)"
test "$enable_fixed" = "yes" || \
echo " Allow 'fixed' rrset-order (--enable-fixed-rrset)"
if test "X$CRYPTO" = "X" -o "$want_native_pkcs11" = "yes"
elif test "$use_pkcs11" = "no"; then
echo " PKCS#11/Cryptoki support (--with-pkcs11)"
test "$want_native_pkcs11" = "yes" ||
echo " Native PKCS#11/Cryptoki support (--enable-native-pkcs11)"
test "X$CRYPTO" = "X" -o "$OPENSSL_GOST" = "yes" -o "$PKCS11_GOST" = "yes" || \
echo " GOST algorithm support (--with-gost)"
test "X$CRYPTO" = "X" -o "$OPENSSL_ECDSA" = "yes" -o "$PKCS11_ECDSA" = "yes" || \
echo " ECDSA algorithm support (--with-ecdsa)"
test "$enable_seccomp" = yes || \
echo " Use libseccomp system call filtering (--enable-seccomp)"
test "$want_backtrace" = "yes" || \
echo " Print backtrace on crash (--enable-backtrace)"
test "$want_querytrace" = "yes" || \
echo " Very verbose query trace logging (--enable-querytrace)"
test "$use_libtool" = "yes" || echo " Use GNU libtool (--with-libtool)"
test "$atf" = "no" && 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)"
if test "X$ac_unrecognized_opts" != "X"; then
echo "Unrecognized options:"
echo " $ac_unrecognized_opts"
if test "$enable_full_report" != "yes"; then
echo "-------------------------------------------------------------------------------"
echo "For more detail, use --enable-full-report."
echo "==============================================================================="
if test "X$CRYPTO" = "X"; then
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.
if test "X$OPENSSL_WARNING" != "X"; then
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING Your OpenSSL crypto library may be vulnerable to WARNING
WARNING one or more of the the following known security WARNING
WARNING CAN-2002-0659, CAN-2006-4339, CVE-2006-2937, WARNING
WARNING CVE-2006-2940 and CVE-2015-3193. WARNING
WARNING It is recommended that you upgrade to OpenSSL WARNING
WARNING version 1.0.2e/1.0.1/1.0.0/0.9.9/0.9.8d/0.9.7l WARNING
WARNING (or greater). WARNING
WARNING You can disable this warning by specifying: WARNING
WARNING --disable-openssl-version-check WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
# Tell Emacs to edit this file in shell mode.