mirror of
https://gitlab.isc.org/isc-projects/bind9.git
synced 2025-04-18 09:44:09 +03:00
1560 lines
50 KiB
Plaintext
1560 lines
50 KiB
Plaintext
# Copyright (C) Internet Systems Consortium, Inc. ("ISC")
|
|
#
|
|
# SPDX-License-Identifier: MPL-2.0
|
|
#
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, you can obtain one at https://mozilla.org/MPL/2.0/.
|
|
#
|
|
# See the COPYRIGHT file distributed with this work for additional
|
|
# information regarding copyright ownership.
|
|
|
|
#
|
|
# Defining the version in m4 requires a bit of dancing around,
|
|
# so the strings are properly concatenated, as you can't use
|
|
# a shell variable in AC_INIT
|
|
#
|
|
m4_define([bind_VERSION_MAJOR], 9)dnl
|
|
m4_define([bind_VERSION_MINOR], 21)dnl
|
|
m4_define([bind_VERSION_PATCH], 8)dnl
|
|
m4_define([bind_VERSION_EXTRA], -dev)dnl
|
|
m4_define([bind_DESCRIPTION], [(Development Release)])dnl
|
|
m4_define([bind_SRCID], [m4_esyscmd_s([git rev-parse --short HEAD | cut -b1-7])])dnl
|
|
m4_define([bind_PKG_VERSION], [[bind_VERSION_MAJOR.bind_VERSION_MINOR.bind_VERSION_PATCH]bind_VERSION_EXTRA])dnl
|
|
|
|
#
|
|
# Autoconf initialization
|
|
#
|
|
AC_INIT([BIND], bind_PKG_VERSION, [https://gitlab.isc.org/isc-projects/bind9/-/issues/new?issuable_template=Bug], [], [https://www.isc.org/downloads/])
|
|
AC_PREREQ([2.69])
|
|
|
|
AC_DEFINE([PACKAGE_VERSION_MAJOR], ["][bind_VERSION_MAJOR]["], [BIND 9 Major part of the version])
|
|
AC_DEFINE([PACKAGE_VERSION_MINOR], ["][bind_VERSION_MINOR]["], [BIND 9 Minor part of the version])
|
|
AC_DEFINE([PACKAGE_VERSION_PATCH], ["][bind_VERSION_PATCH]["], [BIND 9 Patch part of the version])
|
|
AC_DEFINE([PACKAGE_VERSION_EXTRA], ["][bind_VERSION_EXTRA]["], [BIND 9 Extra part of the version])
|
|
AC_DEFINE([PACKAGE_DESCRIPTION], [m4_ifnblank(bind_DESCRIPTION, [" ]bind_DESCRIPTION["], [])], [An extra string to print after PACKAGE_STRING])
|
|
AC_DEFINE([PACKAGE_SRCID], ["][bind_SRCID]["], [A short hash from git])
|
|
|
|
bind_CONFIGARGS="${ac_configure_args:-default}"
|
|
AC_DEFINE_UNQUOTED([PACKAGE_CONFIGARGS], ["$bind_CONFIGARGS"], [Either 'defaults' or used ./configure options])
|
|
|
|
AC_DEFINE([PACKAGE_BUILDER], ["make"], [make or Visual Studio])
|
|
|
|
#
|
|
# Get the Canonical System Type
|
|
#
|
|
AC_CANONICAL_BUILD
|
|
AC_CANONICAL_HOST
|
|
AC_CANONICAL_TARGET
|
|
|
|
AC_CONFIG_SRCDIR([bin/named/main.c])
|
|
AM_INIT_AUTOMAKE([1.14 tar-pax foreign subdir-objects dist-xz no-dist-gzip -Wall -Werror])
|
|
AM_SILENT_RULES([yes])
|
|
AM_EXTRA_RECURSIVE_TARGETS([test unit doc])
|
|
|
|
AC_CONFIG_HEADERS([config.h])
|
|
AC_CONFIG_MACRO_DIR([m4])
|
|
|
|
#
|
|
# Enable maintainer mode by default only when building from git repository
|
|
# and not cross compling
|
|
#
|
|
AS_IF([test "$cross_compiling" = no],
|
|
[AM_MAINTAINER_MODE(m4_ifset([bind_SRCID],[enable],[disable]))],
|
|
[AM_MAINTAINER_MODE([disable])])
|
|
|
|
#
|
|
# Enable system extensions to C and POSIX
|
|
#
|
|
AC_USE_SYSTEM_EXTENSIONS
|
|
|
|
#
|
|
# Compiler compatibility flags
|
|
#
|
|
m4_version_prereq([2.70],
|
|
[AC_PROG_CC],
|
|
[AC_PROG_CC_C99])
|
|
AC_PROG_CPP_WERROR
|
|
|
|
#
|
|
# Find build compiler when cross compiling
|
|
#
|
|
AX_PROG_CC_FOR_BUILD
|
|
|
|
#
|
|
# Find the machine's endian flavor.
|
|
#
|
|
AC_C_BIGENDIAN
|
|
|
|
#
|
|
# Enable large file support
|
|
#
|
|
AC_SYS_LARGEFILE
|
|
AC_FUNC_FSEEKO
|
|
|
|
# Enable RFC 3542 APIs on macOS
|
|
AC_DEFINE([__APPLE_USE_RFC_3542], [1], [Select RFC3542 IPv6 API on macOS])
|
|
|
|
AC_PROG_MAKE_SET
|
|
|
|
# Checks for programs.
|
|
m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) # call AM_PROG_AR only if available
|
|
|
|
AC_PROG_INSTALL
|
|
AC_PROG_LN_S
|
|
AX_POSIX_SHELL
|
|
AC_PROG_MKDIR_P
|
|
|
|
# Initialize libtool
|
|
LT_INIT([disable-static dlopen pic-only])
|
|
|
|
AS_IF([test "$enable_static" != "no" && test "$enable_developer" != "yes"],
|
|
[AC_MSG_ERROR([Static linking is not supported as it disables dlopen() and certain security features (e.g. RELRO, ASLR)])])
|
|
|
|
|
|
#
|
|
# Set the default CFLAGS, CPPFLAGS, and LDFLAGS
|
|
#
|
|
STD_CFLAGS="-Wall -Wextra -Wwrite-strings -Wpointer-arith -Wno-missing-field-initializers -Wformat -Wshadow"
|
|
|
|
# These should be always errors
|
|
STD_CFLAGS="$STD_CFLAGS -Werror=implicit-function-declaration -Werror=missing-prototypes -Werror=format-security -Werror=parentheses -Werror=implicit -Werror=strict-prototypes -Werror=vla"
|
|
|
|
# Disable false positives generated by GCC 11+ and ASAN
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[]],
|
|
[[#if __GNUC__ >= 11 && defined(__SANITIZE_ADDRESS__)
|
|
#error Address Sanitizer enabled
|
|
#endif
|
|
]])],
|
|
[],
|
|
[STD_CFLAGS="$STD_CFLAGS -Wno-stringop-overread"])
|
|
|
|
# Silence GCC 11.1+ note about the changed alignment, see GL #4841
|
|
AS_CASE([$target_cpu],[i?86],[STD_CFLAGS="$STD_CFLAGS -Wno-psabi"])
|
|
|
|
STD_LDFLAGS=""
|
|
|
|
# ... except in test code
|
|
TEST_CFLAGS="-Wno-vla"
|
|
|
|
# Fortify the sources by default (we undefine the macro first in case
|
|
# the compiler has a different built-in setting)
|
|
STD_CPPFLAGS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
|
|
|
|
#
|
|
# Define constexpr if it is missing from the compiler
|
|
#
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[constexpr int foo = 0;]])],
|
|
[],
|
|
[AC_DEFINE([constexpr],[static const],[Define compatibility shim for non-C23 compilers.])])
|
|
|
|
#
|
|
# Additional compiler settings.
|
|
#
|
|
AX_CHECK_COMPILE_FLAG([-fno-strict-aliasing],
|
|
[STD_CFLAGS="$STD_CFLAGS -fno-strict-aliasing"])
|
|
# Clang only issues a warning so use -Werror to force a error.
|
|
AX_CHECK_COMPILE_FLAG([-Werror -fno-delete-null-pointer-checks],
|
|
[STD_CFLAGS="$STD_CFLAGS -fno-delete-null-pointer-checks"])
|
|
AX_CHECK_COMPILE_FLAG([-fdiagnostics-show-option],
|
|
[STD_CFLAGS="$STD_CFLAGS -fdiagnostics-show-option"])
|
|
|
|
AX_CHECK_LINK_FLAG([-Wl,--export-dynamic],
|
|
[STD_LDFLAGS="$STD_LDFLAGS -Wl,--export-dynamic"])
|
|
|
|
host_macos=no
|
|
AS_CASE([$host],[*-darwin*],[host_macos=yes])
|
|
AM_CONDITIONAL([HOST_MACOS], [test "$host_macos" = "yes"])
|
|
|
|
#
|
|
# Change defaults for developers if not explicity set.
|
|
# Needs to be before the option is tested.
|
|
#
|
|
# [pairwise: --enable-developer, --disable-developer]
|
|
AC_ARG_ENABLE([developer],
|
|
[AS_HELP_STRING([--enable-developer],
|
|
[enable developer build settings])])
|
|
|
|
AS_IF([test "$enable_developer" = "yes"],
|
|
[DEVELOPER_MODE=yes
|
|
STD_CPPFLAGS="$STD_CPPFLAGS -DISC_MEM_DEFAULTFILL=1 -DISC_MEM_TRACKLINES=1 -DISC_LIST_CHECKINIT=1 -DISC_STATS_CHECKUNDERFLOW=1 -DISC_MUTEX_ERROR_CHECK=1 -DISC_SOCKET_DETAILS=1"
|
|
test "${enable_querytrace+set}" = set || enable_querytrace=yes
|
|
test "${with_cmocka+set}" = set || with_cmocka=yes
|
|
test "${with_zlib+set}" = set || with_zlib=yes
|
|
test "${enable_warn_error+set}" = set || enable_warn_error=yes
|
|
])
|
|
|
|
AC_SUBST([DEVELOPER_MODE])
|
|
AC_SUBST([STD_CFLAGS])
|
|
AC_SUBST([STD_CPPFLAGS])
|
|
AC_SUBST([STD_LDFLAGS])
|
|
AC_SUBST([TEST_CFLAGS])
|
|
|
|
# [pairwise: --enable-warn-error, --disable-warn-error]
|
|
AC_ARG_ENABLE([warn_error],
|
|
[AS_HELP_STRING([--enable-warn-error],
|
|
[turn on -Werror when compiling])],
|
|
[],[enable_warn_error=no])
|
|
AS_IF([test "$enable_warn_error" = "yes"],
|
|
[STD_CFLAGS="$STD_CFLAGS -Werror"])
|
|
|
|
#
|
|
# Use pkg-config
|
|
#
|
|
|
|
PKG_PROG_PKG_CONFIG
|
|
AS_IF([test -z "$PKG_CONFIG"],
|
|
[AC_MSG_ERROR([The pkg-config script could not be found or is too old.])])
|
|
|
|
#
|
|
# Pick Userspace-RCU flavor (developer only option)
|
|
#
|
|
# [pairwise: skip]
|
|
AC_ARG_WITH([liburcu],
|
|
[AS_HELP_STRING([--with-liburcu=FLAVOR],
|
|
[Build with Userspace-RCU variant (developer-only option) (membarrier|qsbr|mb|bp) [default=membarrier]]))],
|
|
[], [with_liburcu=membarrier])
|
|
|
|
AC_MSG_CHECKING([liburcu flavor])
|
|
AS_CASE([$with_liburcu],
|
|
[membarrier],
|
|
[RCU_FLAVOR="liburcu"
|
|
AC_DEFINE([RCU_MEMBARRIER], [1], [Build with membarrier Userspace-RCU flavor])],
|
|
[qsbr],
|
|
[RCU_FLAVOR="liburcu-qsbr"
|
|
AC_DEFINE([RCU_QSBR], [1], [Build with QSBR Userspace-RCU flavor])],
|
|
[mb],
|
|
[RCU_FLAVOR="liburcu-mb"
|
|
AC_DEFINE([RCU_MB], [1], [Build with mb Userspace-RCU flavor])],
|
|
[bp],
|
|
[RCU_FLAVOR="liburcu-bp"
|
|
AC_DEFINE([RCU_BP], [1], [Build with bulletproof Userspace-RCU flavor])],
|
|
[AC_MSG_ERROR([Invalid Userspace-RCU flavor picked])])
|
|
|
|
AS_IF([test "$with_liburcu" != "membarrier" && test "$enable_developer" != "yes"],
|
|
[AC_MSG_ERROR([Changing Userspace-RCU variant is allowed only in developer mode])])
|
|
|
|
AC_MSG_RESULT([$RCU_FLAVOR])
|
|
|
|
#
|
|
# liburcu << v0.13.0 didn't add -lurcu-common and some toolchains would
|
|
# not add it automatically - we need to add it explicitly in such case.
|
|
#
|
|
PKG_CHECK_MODULES([LIBURCU], [$RCU_FLAVOR >= 0.13.0 liburcu-cds >= 0.13.0], [],
|
|
[PKG_CHECK_MODULES([LIBURCU], [$RCU_FLAVOR >= 0.10.0 liburcu-cds >= 0.10.0],
|
|
[LIBURCU_LIBS="$LIBURCU_LIBS -lurcu-common"])])
|
|
|
|
AC_DEFINE_UNQUOTED([RCU_FLAVOR], ["$RCU_FLAVOR"], [Chosen Userspace-RCU flavor])
|
|
|
|
PKG_CHECK_VERSION([RCU_VERSION], [$RCU_FLAVOR])
|
|
AC_DEFINE_UNQUOTED([RCU_VERSION], ["$RCU_VERSION"], [Compile-time Userspace-RCU version])
|
|
|
|
CFLAGS="$CFLAGS $LIBURCU_CFLAGS"
|
|
LIBS="$LIBS $LIBURCU_LIBS"
|
|
|
|
#
|
|
# Userspace-RCU inlining doesn't work for rcu_deference() with some combination
|
|
# of C compiler and library version.
|
|
#
|
|
AC_MSG_CHECKING([whether we can inline small liburcu functions])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#define URCU_INLINE_SMALL_FUNCTIONS 1
|
|
#include <urcu.h>]],
|
|
[[struct opaque *a; struct opaque *b = rcu_dereference(a);]])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([URCU_INLINE_SMALL_FUNCTIONS], [1], [Inline small (less than 10 lines) functions])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
# Fuzzing is not included in pairwise testing as fuzzing tools are
|
|
# not present in the relevant Docker image.
|
|
#
|
|
# [pairwise: skip]
|
|
AC_ARG_ENABLE([fuzzing],
|
|
[AS_HELP_STRING([--enable-fuzzing=<afl|libfuzzer|ossfuzz>],
|
|
[Enable fuzzing using American Fuzzy Lop or libFuzzer (default=no)])],
|
|
[],
|
|
[enable_fuzzing=no])
|
|
|
|
AC_MSG_CHECKING([whether to enable fuzzing mode])
|
|
AS_CASE([$enable_fuzzing],
|
|
[no],[AC_MSG_RESULT([no])],
|
|
[afl],[
|
|
AC_MSG_RESULT([using AFL])
|
|
AC_DEFINE([ENABLE_AFL], [1],
|
|
[Define to enable American Fuzzy Lop test harness])
|
|
STD_CFLAGS="$STD_CFLAGS -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1"
|
|
FUZZ_LOG_COMPILER="afl.sh"],
|
|
[libfuzzer],[
|
|
AC_MSG_RESULT([using libFuzzer])
|
|
STD_CFLAGS="$STD_CFLAGS -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION=1 -fsanitize=fuzzer-no-link,address,undefined"
|
|
LDFLAGS="$LDFLAGS -fsanitize=address,undefined"
|
|
FUZZ_LDFLAGS="-fsanitize=fuzzer,address,undefined"
|
|
FUZZ_LOG_COMPILER="libfuzzer.sh"],
|
|
[ossfuzz],[
|
|
AC_MSG_RESULT([using OSS-Fuzz])
|
|
FUZZ_LDFLAGS="$LIB_FUZZING_ENGINE"],
|
|
[*],[AC_MSG_ERROR([You need to explicitly select the fuzzer])])
|
|
AM_CONDITIONAL([HAVE_FUZZ_LOG_COMPILER], [test -n "$FUZZ_LOG_COMPILER"])
|
|
AC_SUBST([FUZZ_LOG_COMPILER])
|
|
AC_SUBST([FUZZ_LDFLAGS])
|
|
|
|
AS_IF([test "$enable_fuzzing" = "afl"],
|
|
[AC_MSG_CHECKING("for AFL enabled compiler")
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
|
|
[#ifndef __AFL_COMPILER
|
|
#error AFL compiler required
|
|
#endif
|
|
])],
|
|
[AC_MSG_RESULT([yes])],
|
|
[AC_MSG_ERROR([set CC=afl-<gcc|clang> when --enable-fuzzing=afl is used])])
|
|
])
|
|
|
|
#
|
|
# Perl is optional; it is used only by some of the system test scripts.
|
|
#
|
|
AC_PATH_PROGS([PERL], [perl5 perl])
|
|
AC_SUBST([PERL])
|
|
AM_CONDITIONAL([HAVE_PERL], [test -n "$PERL"])
|
|
|
|
#
|
|
# Python is optional, it is used only by some of the system test scripts.
|
|
#
|
|
AM_PATH_PYTHON([3.6], [], [:])
|
|
AM_CONDITIONAL([HAVE_PYTHON], [test "$PYTHON" != ":"])
|
|
|
|
AC_PATH_PROGS([PYTEST], [pytest-3 py.test-3 pytest py.test pytest-pypy], [])
|
|
AS_IF([test -z "$PYTEST"],
|
|
[AC_MSG_WARN([pytest not found, some system tests will be skipped])])
|
|
AC_SUBST([PYTEST])
|
|
AM_CONDITIONAL([HAVE_PYTEST], [test -n "$PYTEST"])
|
|
|
|
#
|
|
# xsltproc is optional, it is used only by system test scripts.
|
|
#
|
|
AC_PATH_PROG([XSLTPROC], [xsltproc])
|
|
|
|
#
|
|
# Using Solaris linker with gcc on Solaris breaks Thread Local Storage
|
|
#
|
|
AS_CASE([$host],
|
|
[*-solaris*],[
|
|
AS_IF([test "$GCC" = "yes"],
|
|
[LDFLAGS="$LDFLAGS -zrelax=transtls"
|
|
AC_MSG_WARN([When using GNU C Compiler on Solaris, -zrelax=transtls linker flag is used to fix bug in Thread Local Storage])
|
|
])
|
|
])
|
|
|
|
AC_CHECK_HEADERS([fcntl.h regex.h sys/time.h unistd.h sys/mman.h sys/sockio.h sys/select.h sys/sysctl.h net/if6.h net/route.h linux/netlink.h linux/rtnetlink.h], [], [],
|
|
[$ac_includes_default
|
|
#include <sys/param.h>
|
|
#include <sys/socket.h>
|
|
])
|
|
|
|
#
|
|
# Check for C11 thread local storage
|
|
#
|
|
# NOTE: OpenBSD doesn't ship <threads.h>, so we can't require it (yet).
|
|
#
|
|
AC_CHECK_HEADERS([threads.h])
|
|
|
|
#
|
|
# C11 Atomic Operations
|
|
#
|
|
|
|
AC_CHECK_HEADERS([stdatomic.h],
|
|
[],
|
|
[AC_MSG_ERROR([C11 Atomic Operations required, update your toolchain to build BIND 9])])
|
|
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <stdatomic.h>]],
|
|
[[atomic_int_fast32_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);]]
|
|
)],
|
|
[AC_MSG_CHECKING([whether -latomic is needed for 64-bit stdatomic.h functions])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <stdatomic.h>]],
|
|
[[atomic_int_fast64_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);]]
|
|
)],
|
|
[AC_MSG_RESULT([no])],
|
|
[LIBS="$LIBS -latomic"
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <stdatomic.h>]],
|
|
[[atomic_int_fast64_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])],
|
|
[AC_MSG_FAILURE([libatomic needed, but linking with -latomic failed, please fix your toolchain.])])
|
|
])
|
|
],
|
|
[AC_MSG_FAILURE([stdatomic.h header found, but compilation failed, please fix your toolchain.])])
|
|
|
|
AC_C_CONST
|
|
AC_C_INLINE
|
|
AC_C_VOLATILE
|
|
|
|
#
|
|
# Check for yield support on ARM processors
|
|
#
|
|
AS_CASE([$host],
|
|
[arm*|aarch64*],
|
|
[AC_MSG_CHECKING([for ARM yield instruction support])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[]],
|
|
[[__asm__ __volatile__ ("yield")]])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_ARM_YIELD], [1],
|
|
[define if the ARM yield instruction is available])],
|
|
[AC_MSG_RESULT([no])])])
|
|
|
|
#
|
|
# Check for pause support on SPARC processors
|
|
#
|
|
AS_CASE([$host],
|
|
[sparc*],
|
|
[AC_MSG_CHECKING([for pause instruction support])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[]],
|
|
[[__asm__ __volatile__ ("pause")]])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_SPARC_PAUSE], [1],
|
|
[define if the SPARC pause instruction is available])],
|
|
[AC_MSG_RESULT([no])])])
|
|
|
|
AC_CHECK_FUNCS([sysctlbyname])
|
|
|
|
AC_TYPE_SIZE_T
|
|
AC_TYPE_SSIZE_T
|
|
AC_TYPE_UINTPTR_T
|
|
|
|
#
|
|
# check for uname library routine
|
|
#
|
|
AC_MSG_CHECKING([for uname])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#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], [1], [define if uname is available])
|
|
],
|
|
[AC_MSG_RESULT(no)
|
|
AC_MSG_WARN([uname is not correctly supported])
|
|
])
|
|
|
|
#
|
|
# check for GCC malloc attribute
|
|
#
|
|
AX_GCC_FUNC_ATTRIBUTE([malloc])
|
|
|
|
AC_MSG_CHECKING([for extended malloc attributes])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
__attribute__ ((malloc, malloc (free, 1))
|
|
void * xmalloc(size_t sz) { return malloc(sz); }
|
|
]],
|
|
[[
|
|
void *p = xmalloc(8);
|
|
free(p);
|
|
]])],
|
|
[AC_MSG_RESULT(yes)
|
|
AC_DEFINE([HAVE_MALLOC_EXT_ATTR], [1], [define if extended attributes for malloc are available])
|
|
],
|
|
[AC_MSG_RESULT(no)])
|
|
|
|
#
|
|
# check for GCC returns_nonnull attribute
|
|
#
|
|
AX_GCC_FUNC_ATTRIBUTE([returns_nonnull])
|
|
|
|
#
|
|
# how to link math functions?
|
|
#
|
|
AC_SEARCH_LIBS([sqrt],[m])
|
|
|
|
#
|
|
# GeoIP support?
|
|
#
|
|
# Should be on by default if libmaxminddb exists.
|
|
#
|
|
# [pairwise: --enable-geoip --with-maxminddb=auto, --enable-geoip --with-maxminddb=yes, --disable-geoip]
|
|
AC_ARG_ENABLE([geoip],
|
|
[AS_HELP_STRING([--disable-geoip],
|
|
[support GeoIP2 geolocation ACLs if available [default=yes]])],
|
|
[], [enable_geoip="yes"])
|
|
|
|
# [pairwise: skip]
|
|
AC_ARG_WITH([maxminddb],
|
|
[AS_HELP_STRING([--with-maxminddb=PATH],
|
|
[Build with MaxMind GeoIP2 support (auto|yes|no|path) [default=auto]])],
|
|
[], [with_maxminddb="auto"])
|
|
|
|
AS_IF([test "$enable_geoip" = "yes"],
|
|
[AS_CASE([$with_maxminddb],
|
|
[no],[AC_MSG_ERROR([Use '--disable-geoip' to disable the GeoIP])],
|
|
[auto],[PKG_CHECK_MODULES([MAXMINDDB], [libmaxminddb],
|
|
[AC_DEFINE([HAVE_GEOIP2], [1], [Build with GeoIP2 support])
|
|
PKG_CHECK_VAR([MAXMINDDB_PREFIX], [libmaxminddb], [prefix], [], [AC_MSG_ERROR([libmaxminddb prefix not found in pkg-config; set MAXMINDDB_PREFIX in the environment])])
|
|
],[:])],
|
|
[yes],[PKG_CHECK_MODULES([MAXMINDDB], [libmaxminddb],
|
|
[AC_DEFINE([HAVE_GEOIP2], [1], [Build with GeoIP2 support])
|
|
PKG_CHECK_VAR([MAXMINDDB_PREFIX], [libmaxminddb], [prefix], [], [AC_MSG_ERROR([libmaxminddb prefix not found in pkg-config; set MAXMINDDB_PREFIX in the environment])])
|
|
])],
|
|
[ # default
|
|
AX_SAVE_FLAGS([maxminddb])
|
|
MAXMINDDB_CFLAGS="-I$with_maxminddb/include"
|
|
MAXMINDDB_LIBS="-L$with_maxminddb/lib"
|
|
CFLAGS="$CFLAGS $MAXMINDDB_CFLAGS"
|
|
LIBS="$LIBS $MAXMINDDB_LIBS"
|
|
AC_SEARCH_LIBS([MMDB_open], [maxminddb],
|
|
[AC_DEFINE([HAVE_GEOIP2], [1], [Build with GeoIP2 support])
|
|
MAXMINDDB_LIBS="$MAXMINDDB_LIBS $ac_cv_search_MMDB_open"
|
|
AC_MSG_NOTICE([GeoIP2 default database path set to $with_maxminddb/share/GeoIP])
|
|
AS_VAR_COPY([MAXMINDDB_PREFIX], [with_maxminddb])
|
|
],
|
|
[AC_MSG_ERROR([GeoIP2 requested, but libmaxminddb not found])])
|
|
AX_RESTORE_FLAGS([maxminddb])
|
|
])
|
|
AC_ARG_VAR([MAXMINDDB_PREFIX], [value of prefix for MAXMINDDB, overriding pkg-config])
|
|
])
|
|
|
|
AM_CONDITIONAL([HAVE_GEOIP2], [test -n "$MAXMINDDB_LIBS"])
|
|
|
|
AC_SUBST([MAXMINDDB_CFLAGS])
|
|
AC_SUBST([MAXMINDDB_LIBS])
|
|
|
|
AX_PTHREAD
|
|
|
|
LIBS="$PTHREAD_LIBS $LIBS"
|
|
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
|
|
CC="$PTHREAD_CC"
|
|
|
|
AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <pthread.h>]],
|
|
[[(void)pthread_mutexattr_settype(&(pthread_mutexattr_t){ NULL }, PTHREAD_MUTEX_ADAPTIVE_NP);]])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], [1], [Define to 1 if PTHREAD_MUTEX_ADAPTIVE_NP is available])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
AC_CHECK_FUNCS([pthread_attr_getstacksize pthread_attr_setstacksize pthread_barrier_init pthread_spin_init])
|
|
|
|
AC_SEARCH_LIBS([sched_yield],[rt])
|
|
AC_CHECK_FUNCS([sched_yield pthread_yield pthread_yield_np])
|
|
|
|
# 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>])
|
|
|
|
# libuv
|
|
PKG_CHECK_MODULES([LIBUV], [libuv >= 1.37.0], [],
|
|
[PKG_CHECK_MODULES([LIBUV], [libuv >= 1.34.0 libuv < 1.35.0], [],
|
|
[AC_MSG_ERROR([libuv >= 1.34.0 (except 1.35.0 and 1.36.0) not found])])])
|
|
|
|
PKG_CHECK_VERSION([LIBUV_VERSION], [libuv])
|
|
|
|
AX_SAVE_FLAGS([libuv])
|
|
CFLAGS="$CFLAGS $LIBUV_CFLAGS"
|
|
LIBS="$LIBS $LIBUV_LIBS"
|
|
|
|
# libuv recvmmsg support
|
|
AC_CHECK_DECLS([UV_UDP_MMSG_FREE, UV_UDP_MMSG_CHUNK], [], [], [[#include <uv.h>]])
|
|
AC_MSG_CHECKING([whether struct msghdr uses padding for alignment])
|
|
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/socket.h>],
|
|
[const struct msghdr h = { .__pad1 = 0, .__pad2 = 0 };])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_DECL_UV_UDP_RECVMMSG],
|
|
[0], [Disable recvmmsg support on systems with MUSL glibc])],
|
|
[AC_MSG_RESULT([no])
|
|
AC_CHECK_DECLS([UV_UDP_RECVMMSG], [], [], [[#include <uv.h>]])])
|
|
|
|
# libuv recverr support
|
|
AC_CHECK_DECLS([UV_UDP_LINUX_RECVERR], [], [], [[#include <uv.h>]])
|
|
|
|
AX_RESTORE_FLAGS([libuv])
|
|
|
|
# [pairwise: --enable-doh --with-libnghttp2=auto, --enable-doh --with-libnghttp2=yes, --disable-doh]
|
|
AC_ARG_ENABLE([doh],
|
|
[AS_HELP_STRING([--disable-doh], [disable DNS over HTTPS, removes dependency on libnghttp2 (default is --enable-doh)])],
|
|
[], [enable_doh=yes])
|
|
|
|
# [pairwise: skip]
|
|
AC_ARG_WITH([libnghttp2],
|
|
[AS_HELP_STRING([--with-libnghttp2],
|
|
[build with libnghttp2 library [yes|no|auto] (default is auto)])],
|
|
[], [with_libnghttp2="auto"])
|
|
|
|
AS_IF([test "$enable_doh" = "yes"],
|
|
[AS_CASE([$with_libnghttp2],
|
|
[no],[AC_MSG_ERROR([Use '--disable-doh' to disable DNS-over-HTTPS support])],
|
|
[auto|yes],[PKG_CHECK_MODULES([LIBNGHTTP2], [libnghttp2 >= 1.6.0],
|
|
[AC_DEFINE([HAVE_LIBNGHTTP2], [1], [Build with DNS-over-HTTPS support])],
|
|
[AC_MSG_ERROR(m4_normalize([DNS-over-HTTPS support requested, but libnghttp2 not found.
|
|
Either install libnghttp2 or use --disable-doh.]))])],
|
|
[AC_MSG_ERROR([Specifying libnghttp2 installation path is not supported, adjust PKG_CONFIG_PATH instead])])])
|
|
|
|
AM_CONDITIONAL([HAVE_LIBNGHTTP2], [test -n "$LIBNGHTTP2_LIBS"])
|
|
|
|
|
|
#
|
|
# flockfile is usually provided by pthreads
|
|
#
|
|
AC_CHECK_FUNCS([flockfile getc_unlocked])
|
|
|
|
#
|
|
# Look for other ways to allow detection of the number of processors.
|
|
#
|
|
AC_CHECK_FUNCS([sched_getaffinity cpuset_getaffinity])
|
|
|
|
#
|
|
# Do we want to use pthread rwlock?
|
|
#
|
|
# [pairwise: --enable-pthread-rwlock, --disable-pthread-rwlock]
|
|
AC_ARG_ENABLE([pthread_rwlock],
|
|
[AS_HELP_STRING([--enable-pthread-rwlock],
|
|
[use pthread rwlock instead of internal rwlock implementation])],
|
|
[], [enable_pthread_rwlock=no])
|
|
|
|
AS_IF([test "$enable_pthread_rwlock" = "yes"],
|
|
[AC_CHECK_FUNCS([pthread_rwlock_rdlock], [],
|
|
[AC_MSG_ERROR([pthread_rwlock_rdlock requested but not found])])
|
|
AC_DEFINE([USE_PTHREAD_RWLOCK],[1],[Define if you want to use pthread rwlock implementation])
|
|
])
|
|
AM_CONDITIONAL([USE_ISC_RWLOCK], [test "$enable_pthread_rwlock" != "yes"])
|
|
|
|
CRYPTO=OpenSSL
|
|
|
|
#
|
|
# OpenSSL/LibreSSL is mandatory
|
|
#
|
|
PKG_CHECK_MODULES([OPENSSL], [libssl >= 1.1.1 libcrypto >= 1.1.1])
|
|
PKG_CHECK_VERSION([OPENSSL_VERSION], [openssl])
|
|
|
|
AX_SAVE_FLAGS([openssl])
|
|
|
|
CFLAGS="$OPENSSL_CFLAGS $CFLAGS"
|
|
LIBS="$OPENSSL_LIBS $LIBS"
|
|
|
|
#
|
|
# Check for functions added in OpenSSL or LibreSSL
|
|
#
|
|
AC_MSG_CHECKING([for Ed448 support])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[#include <openssl/evp.h>]],
|
|
[[EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(NID_ED448, NULL);]])],
|
|
[AC_DEFINE([HAVE_OPENSSL_ED448], [1], [define if OpenSSL supports Ed448])
|
|
AC_MSG_RESULT([yes])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
AC_CHECK_FUNCS([ERR_get_error_all])
|
|
AC_CHECK_FUNCS([BIO_read_ex BIO_write_ex])
|
|
AC_CHECK_FUNCS([EVP_MD_CTX_get0_md])
|
|
AC_CHECK_FUNCS([EVP_PKEY_eq])
|
|
AC_CHECK_FUNCS([SSL_CTX_set1_cert_store])
|
|
|
|
#
|
|
# Check whether FIPS mode is available and whether we should enable it
|
|
#
|
|
# FIPS is not included in pairwise testing as the relevant Docker image
|
|
# does not support FIPS mode.
|
|
#
|
|
AC_CHECK_FUNCS(EVP_default_properties_enable_fips FIPS_mode)
|
|
|
|
# [pairwise: skip]
|
|
AC_ARG_ENABLE([fips-mode],
|
|
[AS_HELP_STRING([--enable-fips-mode],
|
|
[enable FIPS mode in OpenSSL library [default=no]])],
|
|
[], [enable_fips_mode="no"])
|
|
|
|
AC_MSG_CHECKING([whether to enable FIPS mode in OpenSSL library])
|
|
AS_CASE([$enable_fips_mode],
|
|
[yes], [AC_MSG_RESULT([yes])
|
|
AC_DEFINE([ENABLE_FIPS_MODE], [1], [Define to 1 if you want FIPS mode to be enabled])
|
|
AS_IF([test "x$ac_cv_func_FIPS_mode" != xyes -a "x$ac_cv_func_EVP_default_properties_enable_fips" != xyes],
|
|
AC_MSG_FAILURE([OpenSSL FIPS mode requested but not available.]))],
|
|
[no], [AC_MSG_RESULT([no])])
|
|
|
|
AX_RESTORE_FLAGS([openssl])
|
|
|
|
AC_SUBST([OPENSSL_CFLAGS])
|
|
AC_SUBST([OPENSSL_LIBS])
|
|
|
|
AC_CHECK_FUNCS([clock_gettime])
|
|
|
|
# [pairwise: --with-gssapi=yes, --with-gssapi=auto, --without-gssapi]
|
|
AC_ARG_WITH([gssapi],
|
|
[AS_HELP_STRING([--with-gssapi=[PATH|[/path/]krb5-config]],
|
|
[Specify path for system-supplied GSSAPI
|
|
[default=auto]])],
|
|
[], [with_gssapi="auto"])
|
|
|
|
KRB5_CONFIG=
|
|
AS_CASE([$with_gssapi],
|
|
[no],[AC_MSG_CHECKING([for GSSAPI support])
|
|
AC_MSG_RESULT([no])],
|
|
[yes],[AC_PATH_PROG([KRB5_CONFIG], [krb5-config])
|
|
AS_IF([test -z "$KRB5_CONFIG"],
|
|
[AC_MSG_ERROR([krb5-config required but not found])])],
|
|
[auto],[AC_PATH_PROG([KRB5_CONFIG], [krb5-config])],
|
|
[*krb5-config*],[KRB5_CONFIG="$with_gssapi"],
|
|
[AC_MSG_ERROR([--with-gssapi requires yes|no|auto|/path/to/krb5-config])])
|
|
|
|
GSSAPI_CFLAGS=
|
|
GSSAPI_LIBS=
|
|
KRB5_CFLAGS=
|
|
KRB5_LIBS=
|
|
AS_IF([test -n "$KRB5_CONFIG"],
|
|
[AC_MSG_CHECKING([for gssapi libraries])
|
|
AX_SAVE_FLAGS([gssapi])
|
|
GSSAPI_CFLAGS=`"$KRB5_CONFIG" --cflags gssapi`
|
|
GSSAPI_LIBS=`"$KRB5_CONFIG" --libs gssapi`
|
|
CFLAGS="$CFLAGS $GSSAPI_CFLAGS"
|
|
LIBS="$LIBS $GSSAPI_LIBS"
|
|
AC_MSG_RESULT([$GSSAPI_CFLAGS $GSSAPI_LIBS])
|
|
AC_CHECK_HEADERS([gssapi/gssapi.h], [],
|
|
[AC_CHECK_HEADERS([gssapi.h], [],
|
|
[AC_MSG_ERROR([neither gssapi/gssapi.h nor gssapi.h found])])])
|
|
AC_CHECK_HEADERS([gssapi/gssapi_krb5.h],
|
|
[AC_CHECK_HEADERS([gssapi_krb5.h], []
|
|
[AC_MSG_ERROR([neither gssapi/gssapi_krb5.h nor gssapi_krb5.h found])])])
|
|
AC_CHECK_FUNCS([gss_acquire_cred],[],
|
|
[AC_MSG_ERROR([linking with $GSSAPI_LIBS does not work])])
|
|
AX_RESTORE_FLAGS([gssapi])
|
|
|
|
AC_MSG_CHECKING([for krb5 libraries])
|
|
AX_SAVE_FLAGS([krb5])
|
|
KRB5_CFLAGS=`"$KRB5_CONFIG" --cflags krb5`
|
|
KRB5_LIBS=`$KRB5_CONFIG --libs krb5`
|
|
CFLAGS="$CFLAGS $KRB5_CFLAGS"
|
|
LIBS="$CFLAGS $KRB5_LIBS"
|
|
AC_MSG_RESULT([$KRB5_CFLAGS $KRB5_LIBS])
|
|
AC_CHECK_HEADERS([krb5/krb5.h], [],
|
|
[AC_CHECK_HEADERS([krb5.h], [],
|
|
[AC_MSG_ERROR([neither krb5/krb5.h nor krb5 found])])])
|
|
AC_CHECK_FUNCS([krb5_init_context], [],
|
|
[AC_MSG_ERROR([linking with $KRB5_LIBS failed])])
|
|
AX_RESTORE_FLAGS([krb5])
|
|
|
|
AC_DEFINE([HAVE_GSSAPI], [1], [Define to 1 if you have the Kerberos Framework available])
|
|
# kludge to silence compiler warnings which recommend use of GSS.framework on macOS
|
|
AS_CASE([$host],[*-darwin*],[CFLAGS="$CFLAGS -Wno-deprecated-declarations"])])
|
|
AM_CONDITIONAL([HAVE_GSSAPI], [test -n "$GSSAPI_LIBS"])
|
|
AC_SUBST([GSSAPI_CFLAGS])
|
|
AC_SUBST([GSSAPI_LIBS])
|
|
AC_SUBST([KRB5_CFLAGS])
|
|
AC_SUBST([KRB5_LIBS])
|
|
|
|
#
|
|
# was --with-lmdb specified?
|
|
#
|
|
|
|
# [pairwise: --with-lmdb=auto, --with-lmdb=yes, --without-lmdb]
|
|
AC_ARG_WITH([lmdb],
|
|
[AS_HELP_STRING([--with-lmdb=@<:@PATH@:>@],
|
|
[use LMDB library @<:@default=auto@:>@, optionally specify the prefix for lmdb library])],
|
|
[:],
|
|
[with_lmdb="auto"])
|
|
|
|
ac_lib_lmdb_found=no
|
|
AS_CASE([$with_lmdb],
|
|
[no],[],
|
|
[auto|yes], [PKG_CHECK_MODULES([LMDB], [lmdb],
|
|
[ac_lib_lmdb_found=yes],
|
|
[for ac_lib_lmdb_path in /usr /usr/local /opt /opt/local; do
|
|
AX_LIB_LMDB([$ac_lib_lmdb_path],
|
|
[ac_lib_lmdb_found=yes
|
|
break])
|
|
done
|
|
])],
|
|
[AX_LIB_LMDB([$with_lmdb],[ac_lib_lmdb_found=yes])])
|
|
|
|
# don't fail when in automatic mode
|
|
AS_IF([test "$with_lmdb" = "auto" && test "$ac_lib_lmdb_found" = "no"],
|
|
[with_lmdb=no])
|
|
|
|
# hard fail when LMDB requested, but not found
|
|
AS_IF([test "$with_lmdb" != "no" && test "$ac_lib_lmdb_found" != "yes"],
|
|
[AC_MSG_ERROR([LMDB requested, but not found])])
|
|
|
|
AS_IF([test "$ac_lib_lmdb_found" = "yes"],
|
|
[AC_DEFINE([HAVE_LMDB], [1], [Use lmdb library])])
|
|
|
|
AC_SUBST([LMDB_CFLAGS])
|
|
AC_SUBST([LMDB_LIBS])
|
|
AM_CONDITIONAL([HAVE_LMDB], [test -n "$LMDB_LIBS"])
|
|
|
|
#
|
|
# was --with-libxml2 specified?
|
|
#
|
|
# [pairwise: --with-libxml2=auto, --with-libxml2=yes, --without-libxml2]
|
|
AC_ARG_WITH([libxml2],
|
|
[AS_HELP_STRING([--with-libxml2],
|
|
[build with libxml2 library [yes|no|auto] (default is auto)])],
|
|
[], [with_libxml2="auto"])
|
|
|
|
AS_CASE([$with_libxml2],
|
|
[no],[],
|
|
[auto],[PKG_CHECK_MODULES([LIBXML2], [libxml-2.0 >= 2.6.0],
|
|
[AC_DEFINE([HAVE_LIBXML2], [1], [Use libxml2 library])],
|
|
[:])],
|
|
[yes],[PKG_CHECK_MODULES([LIBXML2], [libxml-2.0 >= 2.6.0],
|
|
[AC_DEFINE([HAVE_LIBXML2], [1], [Use libxml2 library])])],
|
|
[AC_MSG_ERROR([Specifying libxml2 installation path is not supported, adjust PKG_CONFIG_PATH instead])])
|
|
|
|
AM_CONDITIONAL([HAVE_LIBXML2], [test -n "$LIBXML2_LIBS"])
|
|
|
|
#
|
|
# was --with-json-c specified?
|
|
#
|
|
# [pairwise: --with-json-c=detect, --with-json-c=yes, --without-json-c]
|
|
AC_ARG_WITH([json-c],
|
|
[AS_HELP_STRING([--with-json-c],
|
|
[build with json-c library [yes|no|detect] (default is detect)])],
|
|
[], [with_json_c="detect"])
|
|
|
|
AS_CASE([$with_json_c],
|
|
[no],[],
|
|
[detect],[PKG_CHECK_MODULES([JSON_C], [json-c >= 0.11],
|
|
[AC_DEFINE([HAVE_JSON_C], [1], [Use json-c library])],
|
|
[:])],
|
|
[yes],[PKG_CHECK_MODULES([JSON_C], [json-c >= 0.11],
|
|
[AC_DEFINE([HAVE_JSON_C], [1], [Use json-c library])])],
|
|
[AC_MSG_ERROR([Specifying json-c installation path is not supported, adjust PKG_CONFIG_PATH instead])]
|
|
)
|
|
|
|
AM_CONDITIONAL([HAVE_JSON_C], [test -n "$JSON_C_LIBS"])
|
|
|
|
AC_SUBST([JSON_C_CFLAGS])
|
|
AC_SUBST([JSON_C_LIBS])
|
|
|
|
#
|
|
# was --with-zlib specified?
|
|
#
|
|
# [pairwise: --with-zlib=auto, --with-zlib=yes, --without-zlib]
|
|
AC_ARG_WITH([zlib],
|
|
[AS_HELP_STRING([--with-zlib],
|
|
[build with zlib for HTTP compression
|
|
[default=yes]])],
|
|
[], with_zlib="auto")
|
|
|
|
AS_CASE([$with_zlib],
|
|
[no],[],
|
|
[auto],[PKG_CHECK_MODULES([ZLIB], [zlib],
|
|
[AC_DEFINE([HAVE_ZLIB], [1], [Use zlib library])],
|
|
[:])],
|
|
[yes],[PKG_CHECK_MODULES([ZLIB], [zlib],
|
|
[AC_DEFINE([HAVE_ZLIB], [1], [Use zlib library])])],
|
|
[AC_MSG_ERROR([Specifying zlib installation path is not supported, adjust PKG_CONFIG_PATH instead])])
|
|
AC_SUBST([ZLIB_CFLAGS])
|
|
AC_SUBST([ZLIB_LIBS])
|
|
|
|
#
|
|
# Check if the system supports glibc-compatible backtrace() function.
|
|
#
|
|
AC_CHECK_HEADERS([execinfo.h],
|
|
[AC_SEARCH_LIBS([backtrace_symbols], [execinfo],
|
|
[AC_CHECK_FUNCS([backtrace_symbols])])])
|
|
|
|
#
|
|
# Allow forcibly disabling TCP Fast Open support as autodetection might yield
|
|
# confusing results on some systems (e.g. FreeBSD; see set_tcp_fastopen()
|
|
# comment in lib/isc/socket.c).
|
|
#
|
|
# [pairwise: --enable-tcp-fastopen, --disable-tcp-fastopen]
|
|
AC_ARG_ENABLE([tcp_fastopen],
|
|
[AS_HELP_STRING([--disable-tcp-fastopen],
|
|
[disable TCP Fast Open support [default=yes]])],
|
|
[], [enable_tcp_fastopen="yes"])
|
|
|
|
AS_IF([test "$enable_tcp_fastopen" = "yes"],
|
|
[AC_DEFINE([ENABLE_TCP_FASTOPEN], [1], [define if you want TCP_FASTOPEN enabled if available])])
|
|
|
|
#
|
|
# Check for some other useful functions that are not ever-present.
|
|
#
|
|
AC_CHECK_FUNCS([strlcpy strlcat strnstr])
|
|
|
|
#
|
|
# Check for libedit support
|
|
#
|
|
# [pairwise: --with-libedit=auto, --with-libedit=yes, --without-libedit]
|
|
AC_ARG_WITH([libedit],
|
|
[AS_HELP_STRING([--with-libedit=auto|yes|no],
|
|
[specify libedit library [default auto]])],
|
|
[], [with_libedit="auto"])
|
|
|
|
AS_CASE([$with_libedit],
|
|
[no], [],
|
|
[auto], [PKG_CHECK_MODULES([LIBEDIT], [libedit],
|
|
[AC_DEFINE([HAVE_LIBEDIT], [1], [Build with libedit support])],
|
|
[:])],
|
|
|
|
[yes], [PKG_CHECK_MODULES([LIBEDIT], [libedit],
|
|
[AC_DEFINE([HAVE_LIBEDIT], [1], [Build with libedit support])])],
|
|
[AC_MSG_ERROR([Specifying libedit installation path is not supported, adjust PKG_CONFIG_PATH instead])])
|
|
AM_CONDITIONAL([HAVE_LIBEDIT], [test -n "$LIBEDIT_LIBS"])
|
|
AC_SUBST([LIBEDIT_CFLAGS])
|
|
AC_SUBST([LIBEDIT_LIBS])
|
|
|
|
#
|
|
# Security Stuff
|
|
#
|
|
# Note it is very recommended to *not* disable chroot(),
|
|
# this is only because chroot() was made obsolete by Posix.
|
|
#
|
|
# [pairwise: --enable-chroot, --disable-chroot]
|
|
AC_ARG_ENABLE(chroot, AS_HELP_STRING([--disable-chroot], [disable chroot]))
|
|
case "$enable_chroot" in
|
|
yes|'')
|
|
AC_CHECK_FUNCS(chroot)
|
|
;;
|
|
no)
|
|
;;
|
|
esac
|
|
|
|
AS_CASE([$host],
|
|
[*-linux*],
|
|
[PKG_CHECK_MODULES([LIBCAP], [libcap],
|
|
[AC_DEFINE([HAVE_LIBCAP], [1], [Define to 1 if libcap was found])])])
|
|
|
|
case "$host" in
|
|
*-solaris*)
|
|
AC_DEFINE(NEED_SECURE_DIRECTORY, 1,
|
|
[Define if connect does not honour the permission on the UNIX domain socket.])
|
|
;;
|
|
esac
|
|
|
|
#
|
|
# Time Zone Stuff
|
|
#
|
|
AC_CHECK_FUNCS([tzset])
|
|
|
|
AC_MSG_CHECKING(for optarg declaration)
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <unistd.h>]],
|
|
[[optarg = 0;]]
|
|
)],
|
|
[AC_MSG_RESULT(yes)],
|
|
[AC_MSG_RESULT(no)
|
|
GEN_NEED_OPTARG="-DNEED_OPTARG=1"
|
|
AC_DEFINE(NEED_OPTARG, 1, [Defined if extern char *optarg is not declared.])]
|
|
)
|
|
|
|
#
|
|
# Check for nanoseconds in file stats
|
|
#
|
|
AC_MSG_CHECKING([for st_mtim.tv_nsec])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <sys/stat.h>]],
|
|
[[struct stat s;
|
|
return(s.st_mtim.tv_nsec);
|
|
]])],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_STAT_NSEC], [1], [define if struct stat has st_mtim.tv_nsec field])],
|
|
[AC_MSG_RESULT([no])])
|
|
|
|
#
|
|
# Check for if_nametoindex() for IPv6 scoped addresses support
|
|
#
|
|
AC_CHECK_FUNCS([if_nametoindex])
|
|
|
|
AC_CHECK_HEADERS([uchar.h])
|
|
|
|
#
|
|
# Check for __builtin_unreachable
|
|
#
|
|
AC_MSG_CHECKING([compiler support for __builtin_unreachable()])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[]],
|
|
[[__builtin_unreachable();]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_BUILTIN_UNREACHABLE], [1], [define if the compiler supports __builtin_unreachable().])
|
|
],
|
|
[AC_MSG_RESULT([no])
|
|
])
|
|
|
|
#
|
|
# Check for __builtin_clz
|
|
#
|
|
AC_MSG_CHECKING([compiler support for __builtin_clz])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[]],
|
|
[[return (__builtin_clz(0xff) == 24 ? 1 : 0);]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE(HAVE_BUILTIN_CLZ, 1, [Define to 1 if the compiler supports __builtin_clz.])
|
|
],
|
|
[AC_MSG_RESULT([no])]
|
|
)
|
|
|
|
#
|
|
# Check for __builtin_*_overflow
|
|
#
|
|
AC_MSG_CHECKING([compiler support for __builtin_add_overflow()])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <limits.h>]],
|
|
[[return (__builtin_add_overflow((unsigned int)UINT_MAX, (unsigned int)UINT_MAX, &(unsigned int){ 0 }));]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_BUILTIN_ADD_OVERFLOW], [1], [define if the compiler supports __builtin_add_overflow().])
|
|
],
|
|
[AC_MSG_RESULT([no])
|
|
])
|
|
|
|
AC_MSG_CHECKING([compiler support for __builtin_sub_overflow()])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <limits.h>]],
|
|
[[return (__builtin_sub_overflow((unsigned int)0, (unsigned int)UINT_MAX, &(unsigned int){ 0 }));]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_BUILTIN_SUB_OVERFLOW], [1], [define if the compiler supports __builtin_sub_overflow().])
|
|
],
|
|
[AC_MSG_RESULT([no])
|
|
])
|
|
|
|
AC_MSG_CHECKING([compiler support for __builtin_mul_overflow()])
|
|
AC_LINK_IFELSE(
|
|
[AC_LANG_PROGRAM(
|
|
[[#include <limits.h>
|
|
#include <stdint.h>
|
|
]],
|
|
[[return (__builtin_mul_overflow(UINT64_MAX, UINT64_MAX, &(uint64_t){ 0 }));]]
|
|
)],
|
|
[AC_MSG_RESULT([yes])
|
|
AC_DEFINE([HAVE_BUILTIN_MUL_OVERFLOW], [1], [define if the compiler supports __builtin_mul_overflow().])
|
|
],
|
|
[AC_MSG_RESULT([no])
|
|
])
|
|
|
|
#
|
|
# Activate dnstap?
|
|
#
|
|
# [pairwise: --enable-dnstap, --disable-dnstap]
|
|
AC_ARG_ENABLE([dnstap],
|
|
[AS_HELP_STRING([--enable-dnstap],
|
|
[enable dnstap support
|
|
(requires fstrm, protobuf-c)])],
|
|
[], [enable_dnstap=no])
|
|
|
|
AS_IF([test "$enable_dnstap" != "no"],
|
|
[PKG_CHECK_MODULES([DNSTAP], [libfstrm libprotobuf-c], [],
|
|
[AC_MSG_FAILURE([Required libraries (fstrm, protobuf-c) were not found, please install them.])])
|
|
AC_PATH_PROG([FSTRM_CAPTURE], [fstrm_capture])
|
|
AC_PATH_PROG([PROTOC_C], [protoc-c])
|
|
AS_IF([test -z "$PROTOC_C"],
|
|
[AC_MSG_ERROR([protoc-c compiler not found])])
|
|
AC_DEFINE([HAVE_DNSTAP], 1, [Define to 1 to enable dnstap support])
|
|
])
|
|
|
|
AC_SUBST([DNSTAP_CFLAGS])
|
|
AC_SUBST([DNSTAP_LIBS])
|
|
AM_CONDITIONAL([HAVE_DNSTAP], [test "$enable_dnstap" != "no"])
|
|
#
|
|
# The following sections deal with tools used for formatting
|
|
# the documentation. They are all optional, unless you are
|
|
# a developer editing the documentation source.
|
|
#
|
|
|
|
#
|
|
# Look for sphinx-build
|
|
#
|
|
AC_ARG_VAR([SPHINX_BUILD], [path to sphinx-build binary used to build the documentation])
|
|
AC_PATH_PROG([SPHINX_BUILD], [sphinx-build], [])
|
|
AM_CONDITIONAL([HAVE_SPHINX_BUILD], [test -n "$SPHINX_BUILD"])
|
|
|
|
#
|
|
# Build the man pages only if we have prebuilt manpages or we can build them from RST sources
|
|
#
|
|
AM_CONDITIONAL([BUILD_MANPAGES], [test -e doc/man/named.conf.5in || test -n "$SPHINX_BUILD"])
|
|
|
|
#
|
|
# Pull release date from changelog.rst file last modification date
|
|
# for reproducible builds
|
|
#
|
|
release_date=`date -u -r doc/arm/changelog.rst +%Y-%m-%d`
|
|
AC_SUBST([RELEASE_DATE], $release_date)
|
|
|
|
#
|
|
# Look for Doxygen
|
|
#
|
|
AC_PATH_PROGS([DOXYGEN], [doxygen])
|
|
|
|
AC_CONFIG_FILES([doc/doxygen/doxygen-input-filter],
|
|
[chmod +x doc/doxygen/doxygen-input-filter])
|
|
|
|
#
|
|
# Look for curl
|
|
#
|
|
|
|
AC_PATH_PROG(CURL, curl, curl)
|
|
AC_SUBST(CURL)
|
|
|
|
#
|
|
# Look for nc
|
|
#
|
|
|
|
AC_PATH_PROGS(NC, nc, nc)
|
|
AC_SUBST(NC)
|
|
|
|
#
|
|
# IDN support using libidn2
|
|
#
|
|
|
|
LIBIDN2_CFLAGS=
|
|
LIBIDN2_LIBS=
|
|
|
|
# [pairwise: --with-libidn2=yes, --without-libidn2]
|
|
AC_ARG_WITH([libidn2],
|
|
[AS_HELP_STRING([--with-libidn2[=PATH]], [enable IDN support using GNU libidn2 [yes|no(default)|path]])],
|
|
[with_libidn2="$withval"], [with_libidn2="no"])
|
|
AS_CASE([$with_libidn2],
|
|
[yes], [PKG_CHECK_MODULES([LIBIDN2], [libidn2],
|
|
[AC_DEFINE([HAVE_LIBIDN2], [1], [Define if libidn2 was found])])],
|
|
[no], [],
|
|
[*], [AX_SAVE_FLAGS([libidn2])
|
|
LIBIDN2_CFLAGS="-I$with_libidn2/include"
|
|
LIBIDN2_LIBS="-L$with_libidn2/lib"
|
|
CFLAGS="$CFLAGS $LIBIDN2_CFLAGS"
|
|
LIBS="$LIBS $LIBIDN2_LIBS"
|
|
AC_CHECK_HEADERS([idn2.h],
|
|
[],
|
|
[AC_MSG_ERROR([idn2.h not found])])
|
|
AC_SEARCH_LIBS([idn2_to_ascii_lz], [idn2],
|
|
[LIBIDN2_LIBS="$LIBIDN2_LIBS $ac_cv_search_idn2_to_ascii_lz"
|
|
AC_DEFINE([HAVE_LIBIDN2], [1], [Define if libidn2 was found])],
|
|
[AC_MSG_ERROR([libidn2 requested, but not found])])
|
|
AX_RESTORE_FLAGS([libidn2])])
|
|
AC_SUBST([LIBIDN2_CFLAGS])
|
|
AC_SUBST([LIBIDN2_LIBS])
|
|
|
|
#
|
|
# Check whether to build with cmocka unit testing framework
|
|
#
|
|
# [pairwise: --with-cmocka=detect, --with-cmocka=yes, --without-cmocka]
|
|
AC_ARG_WITH([cmocka],
|
|
[AS_HELP_STRING([--with-cmocka=detect],[enable CMocka based tests (default is detect)])],
|
|
[],[with_cmocka=detect])
|
|
|
|
AS_CASE([$with_cmocka],
|
|
[no],[],
|
|
[detect],[PKG_CHECK_MODULES([CMOCKA], [cmocka >= 1.1.3],
|
|
[AC_DEFINE([HAVE_CMOCKA], [1], [Use CMocka])
|
|
with_cmocka=yes],[with_cmocka=no])],
|
|
[yes],[PKG_CHECK_MODULES([CMOCKA], [cmocka >= 1.1.3],
|
|
[AC_DEFINE([HAVE_CMOCKA], [1], [Use CMocka])])],
|
|
[AC_MSG_ERROR([Use PKG_CONFIG_PATH to specify path to CMocka library])]
|
|
)
|
|
AC_SUBST([CMOCKA_CFLAGS])
|
|
AC_SUBST([CMOCKA_LIBS])
|
|
|
|
AM_CONDITIONAL([HAVE_CMOCKA], [test "$with_cmocka" = "yes"])
|
|
|
|
#
|
|
# Compile with jemalloc (either provided as package or wired in the system on FreeBSD)
|
|
#
|
|
# [pairwise: --with-jemalloc=detect, --with-jemalloc=yes, --without-jemalloc]
|
|
AC_ARG_WITH([jemalloc],
|
|
[AS_HELP_STRING([--with-jemalloc=detect],[enable jemalloc memory allocator (default is detect)])],
|
|
[],[with_jemalloc=detect])
|
|
|
|
AS_CASE([$with_jemalloc],
|
|
[no],[],
|
|
[yes],[AX_CHECK_JEMALLOC(
|
|
[AC_DEFINE([HAVE_JEMALLOC], [1], [Define to 1 if jemalloc is available])],
|
|
[AC_MSG_ERROR([jemalloc not found])])],
|
|
[AX_CHECK_JEMALLOC(
|
|
[AC_DEFINE([HAVE_JEMALLOC], [1], [Define to 1 if jemalloc is available])
|
|
with_jemalloc=yes],
|
|
[AC_MSG_WARN([jemalloc not found; performance will be reduced])
|
|
with_jemalloc=no])])
|
|
|
|
AS_IF([test "$with_jemalloc" = "no"],
|
|
[AS_CASE([$host],
|
|
[*-freebsd*],[AC_MSG_ERROR([You cannot compile without jemalloc; jemalloc is the system allocator on FreeBSD])])])
|
|
|
|
AM_CONDITIONAL([HAVE_JEMALLOC], [test "$with_jemalloc" = "yes"])
|
|
|
|
#
|
|
# Check memory leaks in external libraries
|
|
#
|
|
# [pairwise: --enable-leak-detection, --disable-leak-detection]
|
|
AC_ARG_ENABLE([leak-detection],
|
|
[AS_HELP_STRING([--enable-leak-detection],[enable the memory leak detection in external libraries (libxml2, libuv, OpenSSL) (disabled by default)])],
|
|
[],[enable_leak_detection=no])
|
|
AS_CASE([$enable_leak_detection],
|
|
[yes],[AC_DEFINE([ENABLE_LEAK_DETECTION], [1], [Define to enable memory leak detection in external libraries])])
|
|
|
|
#
|
|
# was --enable-querytrace or --enable-singletrace specified?
|
|
#
|
|
# [pairwise: --enable-singletrace --enable-querytrace, --disable-singletrace --enable-querytrace, --disable-singletrace --disable-querytrace]
|
|
AC_ARG_ENABLE([singletrace],
|
|
AS_HELP_STRING([--enable-singletrace],
|
|
[enable single-query trace logging
|
|
[default=no]]),
|
|
enable_singletrace="$enableval", enable_singletrace="no")
|
|
|
|
AC_MSG_CHECKING([whether to enable single-query trace logging])
|
|
case "$enable_singletrace" in
|
|
yes)
|
|
enable_querytrace=yes
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(WANT_SINGLETRACE, 1, [Define to enable single-query tracing.])
|
|
;;
|
|
no)
|
|
AC_MSG_RESULT(no)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR("--enable-singletrace requires yes or no")
|
|
;;
|
|
esac
|
|
|
|
# [pairwise: skip]
|
|
AC_ARG_ENABLE(querytrace,
|
|
AS_HELP_STRING([--enable-querytrace],
|
|
[enable very verbose query trace logging
|
|
[default=no]]),
|
|
enable_querytrace="$enableval",
|
|
enable_querytrace="$enable_singletrace")
|
|
|
|
AC_MSG_CHECKING([whether to enable query trace logging])
|
|
case "$enable_querytrace" in
|
|
yes)
|
|
AC_MSG_RESULT(yes)
|
|
AC_DEFINE(WANT_QUERYTRACE, 1, [Define to enable very verbose query trace logging.])
|
|
;;
|
|
no)
|
|
AS_IF([test "$enable_singletrace" = "yes"],
|
|
[AC_MSG_ERROR([--enable-singletrace requires --enable-querytrace])])
|
|
AC_MSG_RESULT(no)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR(["--enable-querytrace requires yes or no (not $enable_querytrace)"])
|
|
;;
|
|
esac
|
|
|
|
#
|
|
# Was --disable-auto-validation specified?
|
|
#
|
|
|
|
validation_default=auto
|
|
|
|
# [pairwise: --enable-auto-validation, --disable-auto-validation]
|
|
AC_ARG_ENABLE(auto-validation,
|
|
AS_HELP_STRING([--enable-auto-validation],
|
|
[turn on DNSSEC validation by default, using the IANA root key [default=yes]]),
|
|
[:],[enable_auto_validation=yes])
|
|
AS_IF([test "$enable_auto_validation" = "no"],[validation_default=yes])
|
|
AC_DEFINE_UNQUOTED([VALIDATION_DEFAULT], ["$validation_default"], [the default value of dnssec-validation option])
|
|
|
|
#
|
|
# Support for constructor and destructor attributes
|
|
#
|
|
AX_GCC_FUNC_ATTRIBUTE([constructor])
|
|
AX_GCC_FUNC_ATTRIBUTE([destructor])
|
|
|
|
#
|
|
# Check whether to enable User Statically Defined Tracing.
|
|
#
|
|
# This is supported only on Linux now and requires SystemTap libraries.
|
|
#
|
|
# [pairwise: --enable-tracing=auto, --enable-tracing=yes, --disable-tracing]
|
|
AC_ARG_ENABLE([tracing],
|
|
[AS_HELP_STRING([--enable-tracing],
|
|
[enable User Statically Defined Tracing])],
|
|
[],
|
|
[enable_tracing=auto])
|
|
|
|
AC_ARG_VAR([DTRACE], [path to dtrace binary used to build User Statically Defined Tracing probes])
|
|
AC_PATH_PROGS([DTRACE], [dtrace])
|
|
AC_CHECK_HEADERS([sys/sdt.h])
|
|
|
|
AC_MSG_CHECKING([whether to enable User Statically Defined Tracing support (default is auto)])
|
|
AS_CASE([$enable_tracing],
|
|
[auto], [enable_tracing=yes
|
|
AS_IF([test "$ac_cv_header_sys_sdt_h" != "yes"], [enable_tracing=no])
|
|
AS_IF([test -z "$DTRACE"],[enable_tracing=no])
|
|
AC_COMPILE_IFELSE(
|
|
[AC_LANG_PROGRAM([[]],
|
|
[[#if !defined(__has_feature)
|
|
#define __has_feature(x) 0
|
|
#endif /* if !defined(__has_feature) */
|
|
#if __has_feature(address_sanitizer)
|
|
#define __SANITIZE_ADDRESS__ 1
|
|
#endif /* if __has_feature(address_sanitizer) */
|
|
#if defined(__SANITIZE_ADDRESS__)
|
|
#error Address Sanitizer enabled
|
|
#endif
|
|
]])],
|
|
[],
|
|
[enable_tracing=no]
|
|
)])
|
|
AS_CASE([$enable_tracing],
|
|
[yes], [AS_IF([test "$ac_cv_header_sys_sdt_h" != "yes"],
|
|
[AC_MSG_ERROR([sys/sdt.h header not found])])
|
|
AS_IF([test -z "$DTRACE"],
|
|
[AC_MSG_ERROR([The dtrace command not found])])
|
|
AC_MSG_RESULT([yes])],
|
|
[DTRACE=""
|
|
AC_MSG_RESULT([no])])
|
|
|
|
AS_CASE([$host],
|
|
[*-linux*],[have_systemtap=true])
|
|
|
|
AM_CONDITIONAL([HAVE_SYSTEMTAP], [test -n "$have_systemtap"])
|
|
AM_CONDITIONAL([HAVE_DTRACE], [test -n "$DTRACE"])
|
|
|
|
# Use shim script if dtrace is not available
|
|
AS_IF([test -z "$DTRACE"],
|
|
[DTRACE='$(top_srcdir)/util/dtrace.sh'])
|
|
|
|
AC_SUBST([DTRACE])
|
|
|
|
#
|
|
# We only support QP zone and cache databases
|
|
#
|
|
AC_DEFINE_UNQUOTED([ZONEDB_DEFAULT], ["qpzone"], [Default zone database type])
|
|
AC_DEFINE_UNQUOTED([CACHEDB_DEFAULT], ["qpcache"], [Default cache database type])
|
|
|
|
#
|
|
# Files to configure. These are listed here because we used to
|
|
# specify them as arguments to AC_OUTPUT.
|
|
#
|
|
|
|
# Top
|
|
|
|
AC_CONFIG_FILES([Makefile])
|
|
|
|
# Binaries
|
|
|
|
AC_CONFIG_FILES([bin/Makefile
|
|
bin/named/Makefile
|
|
bin/rndc/Makefile
|
|
bin/dig/Makefile
|
|
bin/delv/Makefile
|
|
bin/dnssec/Makefile
|
|
bin/tools/Makefile
|
|
bin/nsupdate/Makefile
|
|
bin/check/Makefile
|
|
bin/confgen/Makefile
|
|
bin/plugins/Makefile])
|
|
|
|
# Libraries
|
|
|
|
AC_CONFIG_FILES([lib/Makefile
|
|
lib/isc/Makefile
|
|
lib/dns/Makefile
|
|
lib/ns/Makefile
|
|
lib/isccfg/Makefile
|
|
lib/isccc/Makefile])
|
|
|
|
# Documentation
|
|
|
|
AC_CONFIG_FILES([doc/Makefile
|
|
doc/arm/Makefile
|
|
doc/man/Makefile
|
|
doc/misc/Makefile])
|
|
|
|
# Unit tests and benchmarks
|
|
|
|
AC_CONFIG_FILES([tests/Makefile
|
|
tests/bench/Makefile
|
|
tests/isc/Makefile
|
|
tests/dns/Makefile
|
|
tests/ns/Makefile
|
|
tests/isccfg/Makefile
|
|
tests/libtest/Makefile])
|
|
|
|
AC_CONFIG_FILES([tests/unit-test-driver.sh],
|
|
[chmod +x tests/unit-test-driver.sh])
|
|
|
|
# System Tests
|
|
|
|
AC_CONFIG_FILES([bin/tests/Makefile
|
|
bin/tests/system/Makefile
|
|
bin/tests/system/isctest/vars/.ac_vars/TOP_BUILDDIR
|
|
bin/tests/system/isctest/vars/.ac_vars/TOP_SRCDIR
|
|
bin/tests/system/isctest/vars/.ac_vars/FSTRM_CAPTURE
|
|
bin/tests/system/isctest/vars/.ac_vars/SHELL
|
|
bin/tests/system/isctest/vars/.ac_vars/PYTHON
|
|
bin/tests/system/isctest/vars/.ac_vars/PERL
|
|
bin/tests/system/isctest/vars/.ac_vars/CURL
|
|
bin/tests/system/isctest/vars/.ac_vars/NC
|
|
bin/tests/system/isctest/vars/.ac_vars/XSLTPROC
|
|
bin/tests/system/isctest/vars/.ac_vars/PYTEST
|
|
bin/tests/system/dyndb/driver/Makefile
|
|
bin/tests/system/dlzexternal/driver/Makefile
|
|
bin/tests/system/hooks/driver/Makefile
|
|
])
|
|
|
|
AC_CONFIG_FILES([bin/tests/system/ifconfig.sh],
|
|
[chmod +x bin/tests/system/ifconfig.sh])
|
|
AC_CONFIG_FILES([bin/tests/system/start.sh],
|
|
[chmod +x bin/tests/system/start.sh])
|
|
AC_CONFIG_FILES([bin/tests/system/stop.sh],
|
|
[chmod +x bin/tests/system/stop.sh])
|
|
|
|
# Fuzz Tests
|
|
|
|
AC_CONFIG_FILES([fuzz/Makefile])
|
|
|
|
# Misc
|
|
|
|
AC_CONFIG_FILES([util/check-make-install])
|
|
|
|
#
|
|
# Do it
|
|
#
|
|
|
|
AC_OUTPUT
|
|
|
|
# [pairwise: --enable-full-report, --disable-full-report]
|
|
AC_ARG_ENABLE(full-report,
|
|
AS_HELP_STRING([--enable-full-report],
|
|
[report values of all configure options]))
|
|
|
|
report() {
|
|
echo "==============================================================================="
|
|
echo "Configuration summary:"
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo "Optional features enabled:"
|
|
if test "yes" = "$with_jemalloc"; then
|
|
echo " Memory allocator: jemalloc"
|
|
fi
|
|
if test "yes" = "$enable_full_report" -o "rbt" = "$zonedb"; then
|
|
echo " Default zone database type: $zonedb"
|
|
fi
|
|
if test "yes" = "$enable_full_report" -o "rbt" = "$zonedb"; then
|
|
echo " Default cache database type: $cachedb"
|
|
fi
|
|
test "no" = "$enable_dnstap" || \
|
|
echo " Allow 'dnstap' packet logging (--enable-dnstap)"
|
|
test -z "$MAXMINDDB_LIBS" || echo " GeoIP2 access control (--enable-geoip)"
|
|
test -z "$GSSAPI_LIBS" || echo " GSS-API (--with-gssapi)"
|
|
|
|
# these lines are only printed if run with --enable-full-report
|
|
if test "yes" = "$enable_full_report"; then
|
|
test -z "$LIBXML2_LIBS" || echo " XML statistics (--with-libxml2)"
|
|
test -z "$JSON_C_LIBS" || echo " JSON statistics (--with-json-c): $JSON_C_CFLAGS $JSON_C_LIBS"
|
|
test -z "$ZLIB_LIBS" || echo " HTTP zlib compression (--with-zlib)"
|
|
test -z "$LMDB_LIBS" || echo " LMDB database to store configuration for 'addzone' zones (--with-lmdb)"
|
|
test -z "$LIBIDN2_LIBS" || echo " IDN support (--with-libidn2)"
|
|
fi
|
|
|
|
test "yes" = "$enable_fips_mode" && \
|
|
echo " FIPS mode in OpenSSL (--enable-fips-mode)"
|
|
|
|
test "yes" = "$enable_querytrace" && \
|
|
echo " Very verbose query trace logging (--enable-querytrace)"
|
|
test "yes" = "$enable_singletrace" && \
|
|
echo " Single-query trace logging (--enable-singletrace)"
|
|
test -z "$HAVE_CMOCKA" || echo " CMocka Unit Testing Framework (--with-cmocka)"
|
|
|
|
test "auto" = "$validation_default" && echo " DNSSEC validation active by default (--enable-auto-validation)"
|
|
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo " Library versions:"
|
|
echo " OpenSSL: $OPENSSL_VERSION"
|
|
echo " libuv: $LIBUV_VERSION"
|
|
echo " Userspace-RCU: $RCU_VERSION"
|
|
if test "no" != "$with_jemalloc"; then
|
|
echo " jemalloc: $JEMALLOC_VERSION"
|
|
fi
|
|
echo "-------------------------------------------------------------------------------"
|
|
|
|
echo "Features disabled or unavailable on this platform:"
|
|
if test "no" = "$with_jemalloc"; then
|
|
echo " Memory allocator: system"
|
|
echo
|
|
echo " +------------------------------------------+"
|
|
echo " | ==== WARNING ==== |"
|
|
echo " | |"
|
|
echo " | This is NOT a recommended configuration. |"
|
|
echo " | Using the system memory allocator causes |"
|
|
echo " | reduced performance and increased memory |"
|
|
echo " | fragmentation. Installing the jemalloc |"
|
|
echo " | memory allocator (version >= 4.0.0) is |"
|
|
echo " | strongly recommended. |"
|
|
echo " +------------------------------------------+"
|
|
echo
|
|
fi
|
|
|
|
test "no" = "$enable_dnstap" && \
|
|
echo " Allow 'dnstap' packet logging (--enable-dnstap)"
|
|
test -z "$MAXMINDDB_LIBS" && echo " GeoIP2 access control (--enable-geoip)"
|
|
test -z "$GSSAPI_LIBS" && echo " GSS-API (--with-gssapi)"
|
|
|
|
test "yes" = "$validation_default" && echo " DNSSEC validation requires configuration (--enable-auto-validation)"
|
|
|
|
test "yes" = "$enable_fips_mode" || \
|
|
echo " FIPS mode in OpenSSL (--enable-fips-mode)"
|
|
|
|
test "yes" = "$enable_querytrace" || \
|
|
echo " Very verbose query trace logging (--enable-querytrace)"
|
|
test "yes" = "$enable_singletrace" || \
|
|
echo " Single-query trace logging (--enable-singletrace)"
|
|
|
|
test "no" = "$with_cmocka" && echo " CMocka Unit Testing Framework (--with-cmocka)"
|
|
|
|
test -z "$LIBXML2_LIBS" && echo " XML statistics (--with-libxml2)"
|
|
test -z "$JSON_C_LIBS" && echo " JSON statistics (--with-json-c)"
|
|
test -z "$ZLIB_LIBS" && echo " HTTP zlib compression (--with-zlib)"
|
|
test -z "$LMDB_LIBS" && echo " LMDB database to store configuration for 'addzone' zones (--with-lmdb)"
|
|
test -z "$LIBIDN2_LIBS" && echo " IDN support (--with-libidn2)"
|
|
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo "Configured paths:"
|
|
echo " prefix: $prefix"
|
|
echo " sysconfdir: $sysconfdir"
|
|
echo " localstatedir: $localstatedir"
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo "Compiler: $CC"
|
|
AS_IF([test "$GCC" = "yes"],
|
|
[$CC --version 2>&1 | sed 's/^/ /'],
|
|
[AS_CASE([$host],
|
|
[*-solaris*],[$CC -V 2>&1 | sed 's/^/ /'],
|
|
[$CC --version 2>&1 | sed 's/^/ /'])])
|
|
echo "CFLAGS: $STD_CFLAGS $CFLAGS"
|
|
echo "CPPFLAGS: $STD_CPPFLAGS $CPPFLAGS"
|
|
echo "LDFLAGS: $LDFLAGS"
|
|
|
|
if test "X$ac_unrecognized_opts" != "X"; then
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo "Unrecognized options:"
|
|
echo " $ac_unrecognized_opts"
|
|
fi
|
|
|
|
if test "yes" != "$enable_full_report"; then
|
|
echo "-------------------------------------------------------------------------------"
|
|
echo "For more detail, use --enable-full-report."
|
|
fi
|
|
echo "==============================================================================="
|
|
}
|
|
|
|
if test "yes" != "$silent"; then
|
|
report
|
|
fi
|
|
|
|
# Tell Emacs to edit this file in shell mode.
|
|
# Local Variables:
|
|
# mode: sh
|
|
# End:
|