mirrors/libmicrohttpd
2
0
Fork 0
mirror of https://git.gnunet.org/libmicrohttpd.git synced 2026-09-25 04:09:31 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
fac57219474d08ef559e87bf1b08f00baccb5bd4
libmicrohttpd/configure.ac
T
Evgeny Grin (Karlson2k) fac5721947 Reworked 'po' directory files and 'po' infrastructure handling 
The project makefiles should handle rebuild of all required autopoint files.
The new implementation uses unpatched autopoint files to simplify updates.
Any missing distribution file should be recreated automatically when
required (before making 'dist' targets).
This implementation should work well with parallel make.
2023-05-25 10:44:49 +02:00

5016 lines
160 KiB
Plaintext
Raw Blame History

# This file is part of libmicrohttpd.
# (C) 2006-2021 Christian Grothoff (and other contributing authors)
# (C) 2014-2023 Evgeny Grin (Karlson2k)
#
# libmicrohttpd is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 3, or (at your
# option) any later version.
#
# libmicrohttpd is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with libmicrohttpd; see the file COPYING. If not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
# Boston, MA 02110-1301, USA.
#
#
# Process this file with autoconf to produce a configure script.
#
#
AC_PREREQ([2.64])
LT_PREREQ([2.4.0])
AC_INIT([GNU libmicrohttpd],[0.9.76],[libmicrohttpd@gnu.org])
AC_CONFIG_AUX_DIR([build-aux])
MHD_AUX_DIR='build-aux' # Must be set to the same value as in the previous line
AC_CONFIG_HEADERS([MHD_config.h])
AC_CONFIG_MACRO_DIR([m4])
m4_pattern_forbid([^_?MHD_[A-Z_]+_CC_])dnl
LIB_VERSION_CURRENT=73
LIB_VERSION_REVISION=0
LIB_VERSION_AGE=61
AC_SUBST([LIB_VERSION_CURRENT])
AC_SUBST([LIB_VERSION_REVISION])
AC_SUBST([LIB_VERSION_AGE])
PACKAGE_VERSION_MAJOR='m4_car(m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'
PACKAGE_VERSION_MINOR='m4_argn(2, m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'
PACKAGE_VERSION_SUBMINOR='m4_argn(3, m4_unquote(m4_split(AC_PACKAGE_VERSION, [\.])))'
AS_VAR_ARITH([MHD_W32_DLL_SUFF],[[$LIB_VERSION_CURRENT - $LIB_VERSION_AGE]])
AC_SUBST([PACKAGE_VERSION_MAJOR])
AC_SUBST([PACKAGE_VERSION_MINOR])
AC_SUBST([PACKAGE_VERSION_SUBMINOR])
AC_SUBST([MHD_W32_DLL_SUFF])
AC_CONFIG_FILES([src/microhttpd/microhttpd_dll_res.rc])
MHD_LIB_CPPFLAGS=""
MHD_LIB_CFLAGS=""
MHD_LIB_LDFLAGS=""
MHD_LIBDEPS=""
# for pkg-config
MHD_REQ_PRIVATE=''
MHD_LIBDEPS_PKGCFG=''
AS_IF([test -z "$CC" && test -z "$CPP"], [
AC_MSG_CHECKING([[whether z/OS special settings are required]])
AS_IF([test `uname -s` = "OS/390"],
[
# configure binaries for z/OS
AS_IF([test -z "$CC"],
[CC=`pwd`"/contrib/xcc"
chmod +x $CC || true])
AS_IF([test -z "$CPP"],
CPP="c89 -E")
AC_MSG_RESULT([[yes]])
],
[AC_MSG_RESULT([[no]])]
)
])
AC_MSG_CHECKING([for build type])
AC_ARG_ENABLE([build-type],
[AS_HELP_STRING([[--enable-build-type=TYPE]],
[enable build TYPE, a set of configuration parameters; individual settings ]
[(asserts, sanitizers, compiler and linker flags) can be overridden by ]
[additional configure parameters (debug, debugger, neutral, release, release-compact, ]
[release-hardened) [neutral]])],
[], [enable_build_type=neutral])
AS_IF([test "x${enable_build_type}" = "x"], [enable_build_type="neutral"])
AS_VAR_IF([enable_build_type], ["no"], [enable_build_type="neutral"])
AS_VAR_IF([enable_build_type], ["yes"], [AC_MSG_ERROR([[Missing TYPE for --enable-build-type=]])])
AS_CASE([${enable_build_type}],
[debug], [AC_MSG_RESULT([debug. Defaults: enable asserts, sanitizers (if any supported), debug information, compiler optimisation for debugging])],
[debugger], [AC_MSG_RESULT([debugger. Defaults: enable asserts, disable sanitizers, debug information, no compiler optimisation, static lib])],
[neutral], [AC_MSG_RESULT([neutral. Defaults: use only user-specified compiler and linker flags])],
[release], [AC_MSG_RESULT([release. Defaults: disable asserts, enable compiler optimisations])],
[release-compact], [AC_MSG_RESULT([release-compact. Defaults: disable asserts, enable compiler optimisations for size, enable compact code])],
[release-hardened], [AC_MSG_RESULT([release-hardened. Defaults: disable asserts, enable compiler optimisations, enable linker and compiler hardening])],
[AC_MSG_ERROR([[Unknown build type: ${enable_build_type}]])]
)
AS_VAR_IF([enable_build_type], ["neutral"], [:],
[
# For all non-neutral build types do not use automatic "-g -O2" for CFLAGS
AS_IF([test -z "${CFLAGS}"], [CFLAGS=""])
]
)
AS_VAR_IF([enable_build_type], ["debugger"],
[ # Build only static version unless something else is specified by the user
AS_IF([test -z "${enable_static}" || test "x${enable_static}" = "xyes"],
[
AS_IF([test -z "${enable_shared}"],
[
enable_shared="no"
enable_static="yes"
]
)
],
[
AS_CASE([${enable_static}],[*libmicrohttpd*],
[AS_IF([test -z "${enable_shared}"], [enable_shared="no"])],
)
]
)
]
)
AS_CASE([${enable_build_type}],[debug|debugger],
[ AS_IF([test -z "${enable_silent_rules}"], [ enable_silent_rules="yes" ])]
)
AM_INIT_AUTOMAKE([gnu] [check-news] [filename-length-max=99] [tar-v7] [silent-rules] [subdir-objects])
# Checks for programs.
AC_PROG_AWK
AC_PROG_GREP
AC_PROG_FGREP
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_CANONICAL_HOST
m4_version_prereq([2.70],
[
# Find C compiler and compiler options to support
# the latest C standard (C11). Fallback to C99 and C89
# if later C versions are not supported.
AC_PROG_CC
],
[
# Find C compiler and compiler options to support
# the latest C standard (C99). Fallback to C89
# if later C versions are not supported.
AC_PROG_CC_STDC
]
)
# Workaround for libgcrypt
AS_IF([[test "x$lt_sysroot" != "x" && test "x$SYSROOT" = "x"]], [[SYSROOT="$lt_sysroot"]])
user_CFLAGS="$CFLAGS"
user_LDFLAGS="$LDFLAGS"
user_CPPFLAGS="$CPPFLAGS"
CFLAGS_ac=""
LDFLAGS_ac=""
CPPFLAGS_ac=""
MHD_SYS_EXT([CPPFLAGS_ac])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
LT_INIT([win32-dll])
LT_LANG([Windows Resource])
AC_ARG_ENABLE([compact-code],
[AS_HELP_STRING([[--enable-compact-code]],
[enable use of a reduced size version of the code, resulting in smaller ]
[binaries with a slight performance hit [auto]])],
[], [enable_compact_code=auto])
AS_IF([test "x${enable_compact_code}" = "x"], [enable_compact_code="auto"])
AH_TEMPLATE([[MHD_FAVOR_SMALL_CODE]], [Define to '1' to use compact code version])
AH_TEMPLATE([[MHD_FAVOR_FAST_CODE]], [Define to '1' to use fast (and larger) code version])
AS_UNSET([compact_code_MSG])
AS_CASE([${enable_compact_code}], [auto],
[
# Parameter not set.
# Check preprocessor macros
AC_CHECK_DECL([MHD_FAVOR_SMALL_CODE],
[
enable_compact_code="yes"
compact_code_MSG="enabled by preprocessor macro"
],
[],[/* no includes */]
)
AC_CHECK_DECL([MHD_FAVOR_FAST_CODE],
[
AS_VAR_IF([enable_compact_code],["yes"],
[AC_MSG_ERROR([Both MHD_FAVOR_SMALL_CODE and MHD_FAVOR_FAST_CODE macros are defined])]
)
enable_compact_code="no"
compact_code_MSG="set by preprocessor macro"
],[],[/* no includes */]
)
AS_VAR_IF([enable_compact_code], ["auto"],
[
# No preference by preprocessor macros
AC_CACHE_CHECK([whether compiler is configured to optimize for size],
[mhd_cv_cc_optim_size],
[
AC_COMPILE_IFELSE(
[
AC_LANG_PROGRAM([[
#ifndef __OPTIMIZE_SIZE__
#error Looks like compiler does not optimize for size
choke me now
#endif
]],[])
],
[mhd_cv_cc_optim_size="yes"],[mhd_cv_cc_optim_size="no"]
)
]
)
AS_VAR_IF([mhd_cv_cc_optim_size], ["yes"],
[
enable_compact_code="yes"
compact_code_MSG="enabled automatically as compiler optimizes for size"
AC_DEFINE([MHD_FAVOR_SMALL_CODE],[1])
]
)
]
)
AS_VAR_IF([enable_compact_code], ["auto"],
[
# No preference by preprocessor macros and compiler flags
AS_CASE([${enable_build_type}],[*-compact],
[
enable_compact_code="yes"
compact_code_MSG="enabled by --enable-build-type=${enable_build_type}"
AC_DEFINE([MHD_FAVOR_SMALL_CODE],[1])
]
)
]
)
AS_VAR_IF([enable_compact_code], ["auto"],
[
# No preference
enable_compact_code="no"
compact_code_MSG="by default"
AC_DEFINE([MHD_FAVOR_FAST_CODE],[1])
]
)
],
[yes],
[
compact_code_MSG="enabled by configure parameter"
AC_CHECK_DECL([MHD_FAVOR_SMALL_CODE],
[],
[AC_DEFINE([MHD_FAVOR_SMALL_CODE],[1])],[/* no includes */]
)
AC_CHECK_DECL([MHD_FAVOR_FAST_CODE],
[AC_MSG_ERROR([MHD_FAVOR_FAST_CODE macro is defined, --enable-compact-code could not be used])
],
[],[/* no includes */]
)
],
[no],
[
compact_code_MSG="disabled by configure parameter"
AC_CHECK_DECL([MHD_FAVOR_FAST_CODE],
[],
[AC_DEFINE([MHD_FAVOR_FAST_CODE],[1])],[/* no includes */]
)
AC_CHECK_DECL([MHD_FAVOR_SMALL_CODE],
[AC_MSG_ERROR([MHD_FAVOR_SMALL_CODE macro is defined, --disable-compact-code could not be used])
],
[],[/* no includes */]
)
],
[AC_MSG_ERROR([[Unknown parameter value: --enable-compact-code=${enable_compact_code}]])]
)
AC_MSG_CHECKING([whether to use a reduced size version of the code])
AC_MSG_RESULT([${enable_compact_code} (${compact_code_MSG})])
CFLAGS="${user_CFLAGS}"
# Compiler options to always enable (if supported)
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-fno-strict-aliasing], [-qnoansialias])
# '-qlonglong' is XLC option for C89, not used with C99 or later
MHD_CHECK_ADD_CC_CFLAG([-qlonglong], [CFLAGS_ac])
# Set basic optimisation flags
AS_VAR_IF([enable_build_type],["neutral"],[],
[ # Any non-neutral build types
AC_CACHE_CHECK([whether workarounds for clang or clang-based compiler are required],
[mhd_cv_cc_clang_based],
[
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#if ! defined(__clang__) && ! defined(__llvm__)
#error Compiler is not clang-based
choke me now
#endif
]]
)
],
[mhd_cv_cc_clang_based="yes"],[mhd_cv_cc_clang_based="no"]
)
]
)
]
)
AS_CASE([${enable_build_type}],[debug|debugger],
[ # Debug build or build for walking with debugger
CFLAGS="${user_CFLAGS}"
AS_VAR_IF([enable_build_type],["debug"],
[
# Clang has ASAN (pointer compare) broken when '-Og' optimisations are used
AS_IF([test "x${enable_sanitizers}" != "xno" && test "x${mhd_cv_cc_clang_based}" = "xyes"],
[MHD_CHECK_ADD_CC_CFLAG([-O0], [CFLAGS_ac])],
[MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Og], [-O0])]
)
],
[MHD_CHECK_ADD_CC_CFLAG([-O0], [CFLAGS_ac])]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
AS_CASE([${enable_build_type}],[release|release-*],
[ # All release types
AS_VAR_IF([enable_build_type],["release-compact"],
[
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
AC_CHECK_DECL([MHD_FAVOR_SMALL_CODE],[],
[AC_CHECK_DECL([MHD_FAVOR_FAST_CODE],[],
[MHD_APPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-DMHD_FAVOR_SMALL_CODE=1])],
[/* no includes */])],[/* no includes */])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${user_CFLAGS}"
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Oz], [-Os], [-O])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
],
[ # All non-compact release types
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
AC_CHECK_DECL([MHD_FAVOR_SMALL_CODE],[],
[AC_CHECK_DECL([MHD_FAVOR_FAST_CODE],[],
[MHD_APPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-DMHD_FAVOR_FAST_CODE=1])],
[/* no includes */])],[/* no includes */])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${user_CFLAGS}"
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-O2], [-O])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
]
)
AS_VAR_IF([enable_build_type],["neutral"],[],
[ # Any non-neutral build types
MHD_CHECK_ADD_CC_CFLAGS([-Wall -Wnull-dereference], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wdeclaration-after-statement -Wimplicit -Wnested-externs], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wredundant-decls -Wtrampolines -Wunsafe-loop-optimizations], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wpoison-system-directories], [CFLAGS_ac])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${user_LDFLAGS}"
MHD_CHECK_ADD_CC_LDFLAG([-Wl,--warn-common], [LDFLAGS_ac])
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
AS_CASE([${enable_build_type}],[debug|debugger],
[ # Debug build or build for walking with debugger
CFLAGS="${user_CFLAGS}"
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-ggdb3], [-g3], [-ggdb], [-g])
MHD_CHECK_ADD_CC_CFLAGS([-Wextra -Wdouble-promotion], [CFLAGS_ac])
MHD_FIND_ADD_CC_CFLAG_IFELSE(
[
# clang produce warning when string pointer is used as a format specifier for v*printf() function
AS_VAR_IF([mhd_cv_cc_clang_based],["yes"],[MHD_CHECK_ADD_CC_CFLAG([-Wno-format-nonliteral], [CFLAGS_ac])])
],[],
[CFLAGS_ac], [-Wformat=2], [-Wformat]
)
MHD_CHECK_ADD_CC_CFLAGS([-Wformat-overflow -Wformat-truncation -Wformat-security -Wformat-signedness], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wmissing-include-dirs -Wshift-overflow=2 -Wstringop-overflow=4 -Walloc-zero], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wduplicated-branches -Wduplicated-cond -Wfloat-equal -Wshadow -Wpointer-arith], [CFLAGS_ac])
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Wshadow-all], [-Wshadow])
MHD_CHECK_ADD_CC_CFLAGS([-Wbad-function-cast -Wcast-qual -Wwrite-strings -Wconversion], [CFLAGS_ac])
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Wcast-align=strict], [-Wcast-align])
MHD_CHECK_ADD_CC_CFLAGS([-Wjump-misses-init -Wlogical-op -Waggregate-return -Wstrict-prototypes], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wold-style-definition -Wmissing-declarations -Wmissing-prototypes], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wuninitialized -Winit-self -Wshift-negative-value -Wswitch-enum], [CFLAGS_ac])
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Wstrict-overflow=4], [-Wstrict-overflow])
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac], [-Wnormalized=nfkc], [-Wnormalized])
MHD_CHECK_ADD_CC_CFLAGS([-Walloca -Wbidi-chars=any -Warray-bounds -Wpacked -Wvariadic-macros], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wundef], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wanon-enum-enum-conversion -Warray-bounds-pointer-arithmetic -Wassign-enum], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wbit-int-extension -Wbitfield-enum-conversion -Wparentheses -Wbool-operation], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wcast-function-type -Wcomma -Wcomment -Wcompound-token-split], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wconditional-uninitialized -Wdeprecated], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wdocumentation-pedantic -Wempty-init-stmt -Wenum-conversion -Wexpansion-to-defined], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wflexible-array-extensions -Wloop-analysis -Wformat-pedantic], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wformat-type-confusion -Wfour-char-constants], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wgcc-compat -Wgnu-anonymous-struct -Wgnu-compound-literal-initializer], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wgnu-conditional-omitted-operand -Wgnu-designator -Wgnu-empty-initializer], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wgnu-empty-struct -Wgnu-flexible-array-initializer -Wgnu-folding-constant], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wgnu-null-pointer-arithmetic -Wgnu-pointer-arith -Wgnu-redeclared-enum], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wgnu-union-cast -Wgnu-variable-sized-type-not-at-end -Widiomatic-parentheses], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wmissing-noreturn -Wmissing-variable-declarations -Wnested-anon-types], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wnewline-eof -Wover-aligned -Wredundant-parens], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wshift-sign-overflow -Wtautological-compare -Wunaligned-access], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wunused -Wzero-as-null-pointer-constant -Wzero-length-array], [CFLAGS_ac])
MHD_CHECK_CC_CFLAG([-Wused-but-marked-unused],[CFLAGS_ac],
[
AC_CACHE_CHECK([whether $[]CC -Wused-but-marked-unused works with system headers],
[mhd_cv_wused_but_marked_unused_sys_header],
[
SAVE_ac_c_werror_flag="$ac_c_werror_flag"
ac_c_werror_flag="yes"
CFLAGS="${CFLAGS_ac} -Wused-but-marked-unused ${user_CFLAGS}"
AC_COMPILE_IFELSE(
[
AC_LANG_SOURCE([[
#include <stdio.h>
int main(void)
{
char buf[16];
return (int) snprintf(buf, 16, "test");
}
]]
)
],
[mhd_cv_wused_but_marked_unused_sys_header="yes"],
[mhd_cv_wused_but_marked_unused_sys_header="no"]
)
ac_c_werror_flag="$SAVE_ac_c_werror_flag"
]
)
AS_VAR_IF([mhd_cv_wused_but_marked_unused_sys_header],["yes"],
[MHD_APPEND_FLAG_TO_VAR([CFLAGS_ac],[-Wused-but-marked-unused])]
)
]
)
#
# Removed flags:
#
# -Wdisabled-macro-expansion - warns about macros from system headers
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${user_LDFLAGS}"
MHD_CHECK_ADD_CC_LDFLAG([-Wl,--enable-long-section-names], [LDFLAGS_ac])
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
AS_CASE([${enable_build_type}],[release|release-*],
[ # All release types
CFLAGS="${user_CFLAGS}"
AS_VAR_IF([enable_build_type],["release-compact"],
[],
[ # All non-compact release types
MHD_CHECK_ADD_CC_CFLAGS([-fsched-pressure -fira-loop-pressure -fmerge-all-constants], [CFLAGS_ac]) # These flags may improve size, recheck with LTO and linker garbage collection
MHD_CHECK_ADD_CC_CFLAGS([-ftree-partial-pre -fgcse-after-reload -fipa-pta], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-fisolate-erroneous-paths-attribute -ffinite-loops -floop-nest-optimize], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-fpredictive-commoning -frename-registers], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-ftree-loop-distribute-patterns -fpeel-loops -fsplit-loops -ftree-vectorize], [CFLAGS_ac])
]
)
AS_VAR_IF([enable_build_type],["release-hardened"],
[
MHD_CHECK_ADD_CC_CFLAGS([-Wformat-security -Wstack-protector], [CFLAGS_ac])
MHD_CHECK_ADD_CC_CFLAGS([-Wuninitialized -Winit-self -Walloc-zero -Wbidi-chars=any], [CFLAGS_ac])
]
)
AS_VAR_IF([enable_build_type],["release"],
[ # Flags are not suitable for 'compact' and for 'hardened'
MHD_CHECK_ADD_CC_CFLAGS([-ffast-math -fno-trapping-math], [CFLAGS_ac])
]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
# W32-specific
LDFLAGS="${user_LDFLAGS}"
MHD_CHECK_ADD_CC_LDFLAG([-Wl,--disable-long-section-names], [LDFLAGS_ac])
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
# Additional flags are checked and added at the end of 'configure'
# Check for headers that are ALWAYS required
AC_CHECK_HEADERS_ONCE([stdio.h string.h stdint.h errno.h limits.h fcntl.h], [],
[AC_MSG_ERROR([Compiling libmicrohttpd requires standard POSIX headers files])], [AC_INCLUDES_DEFAULT])
# Check for basic optional headers
AC_CHECK_HEADERS([stddef.h stdlib.h inttypes.h sys/types.h sys/stat.h unistd.h \
sys/uio.h], [], [], [AC_INCLUDES_DEFAULT])
# Check for clock-specific optional headers
AC_CHECK_HEADERS([sys/time.h time.h], [], [], [AC_INCLUDES_DEFAULT])
# Check for system information and parameters optional headers
AC_CHECK_HEADERS([endian.h machine/endian.h sys/endian.h sys/byteorder.h \
sys/machine.h machine/param.h sys/param.h sys/isa_defs.h \
sys/ioctl.h], [], [], [AC_INCLUDES_DEFAULT])
# Check for network and sockets optional headers
AC_CHECK_HEADERS([sys/socket.h sys/select.h netinet/in.h arpa/inet.h \
netinet/ip.h netinet/tcp.h net/if.h \
netdb.h sockLib.h inetLib.h], [], [],
[AC_INCLUDES_DEFAULT
[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif /* HAVE_INTTYPES_H */
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif /* HAVE_SYS_SOCKET_H */
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif /* HAVE_NETINET_IN_H */
#ifdef HAVE_NETINET_IP_H
#include <netinet/ip.h>
#endif /* HAVE_NETINET_IP_H */
#ifdef HAVE_NETINET_TCP_H
#include <netinet/tcp.h>
#endif /* HAVE_NETINET_TCP_H */
]]
)
# Check for other optional headers
AC_CHECK_HEADERS([sys/msg.h sys/mman.h signal.h], [], [], [AC_INCLUDES_DEFAULT])
AC_CHECK_HEADER([[search.h]],
[
MHD_CHECK_LINK_RUN([[for proper tsearch(), tfind() and tdelete()]],[[mhd_cv_sys_tsearch_usable]],
[
AS_CASE([$host_os],
[openbsd*],
[[ # Some OpenBSD versions have wrong return value for tdelete()
mhd_cv_sys_tsearch_usable='assuming no'
]],
[netbsd*],
[[ # NetBSD had leaked root node for years
mhd_cv_sys_tsearch_usable='assuming no'
]],
[[mhd_cv_sys_tsearch_usable='assuming yes']]
)
],
[
AC_LANG_SOURCE(
[[
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif /* HAVE_STDDEF_H */
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif /* HAVE_STDLIB_H */
#include <stdio.h>
#include <search.h>
static int cmp_func(const void *p1, const void *p2)
{
return (*((const int *)p1)) - (*((const int *)p2));
}
int main(void)
{
int ret = 0;
void *root_ptr = NULL;
int element1 = 1;
int **element_ptr_ptr1;
int **element_ptr_ptr2;
element_ptr_ptr1 =
(int **) tsearch ((void*) &element1, &root_ptr, &cmp_func);
if (NULL == element_ptr_ptr1)
{
fprintf (stderr, "NULL pointer has been returned when tsearch() called for the first time.\n");
return ++ret;
}
if (*element_ptr_ptr1 != &element1)
{
fprintf (stderr, "Wrong pointer has been returned when tsearch() called for the first time.\n");
return ++ret;
}
if (NULL == root_ptr)
{
fprintf (stderr, "Root pointer has not been set by tsearch().\n");
return ++ret;
}
element_ptr_ptr2 =
(int **) tsearch ((void*) &element1, &root_ptr, &cmp_func);
if (NULL == element_ptr_ptr2)
{
fprintf (stderr, "NULL pointer has been returned when tsearch() called for the second time.\n");
return ++ret;
}
if (*element_ptr_ptr2 != &element1)
{
fprintf (stderr, "Wrong pointer has been returned when tsearch() called for the second time.\n");
++ret;
}
if (element_ptr_ptr2 != element_ptr_ptr1)
{
fprintf (stderr, "Wrong element has been returned when tsearch() called for the second time.\n");
++ret;
}
element_ptr_ptr2 =
(int **) tfind ((void*) &element1, &root_ptr, &cmp_func);
if (NULL == element_ptr_ptr2)
{
fprintf (stderr, "NULL pointer has been returned by tfind().\n");
++ret;
}
if (*element_ptr_ptr2 != &element1)
{
fprintf (stderr, "Wrong pointer has been returned when by tfind().\n");
++ret;
}
if (element_ptr_ptr2 != element_ptr_ptr1)
{
fprintf (stderr, "Wrong element has been returned when tsearch() called for the second time.\n");
++ret;
}
element_ptr_ptr1 =
(int **) tdelete ((void*) &element1, &root_ptr, &cmp_func);
if (NULL == element_ptr_ptr1)
{
fprintf (stderr, "NULL pointer has been returned by tdelete().\n");
++ret;
}
if (NULL != root_ptr)
{
fprintf (stderr, "Root pointer has not been set to NULL by tdelete().\n");
++ret;
}
return ret;
}
]]
)
],
[AC_DEFINE([[MHD_USE_SYS_TSEARCH]], [[1]], [Define to 1 if you have properly working tsearch(), tfind() and tdelete() functions.])]
)
],
[], [AC_INCLUDES_DEFAULT]
)
AM_CONDITIONAL([MHD_USE_SYS_TSEARCH], [[test "x$mhd_cv_sys_tsearch_usable" = "xyes" || test "x$mhd_cv_sys_tsearch_usable" = "xassuming yes"]])
# Optional headers used for tests
AC_CHECK_HEADERS([sys/sysctl.h netinet/ip_icmp.h netinet/icmp_var.h], [], [],
[[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif /* HAVE_SYS_SYSCTL_H */
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif /* HAVE_SYS_SOCKET_H */
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif /* HAVE_NETINET_IN_H */
#ifdef HAVE_NETINET_IP_H
#include <netinet/ip.h>
#endif /* HAVE_NETINET_IP_H */
#ifdef HAVE_NETINET_IP_ICMP_H
#include <netinet/ip_icmp.h>
#endif /* HAVE_NETINET_IP_ICMP_H */
]]
)
AC_ARG_ENABLE([compiler-hardening],
[AS_HELP_STRING([--enable-compiler-hardening], [enable compiler security checks])],
[],
[AS_CASE([${enable_build_type}],[*-hardened],
[enable_compiler_hardening='yes'],[enable_compiler_hardening='no'])]
)
AS_VAR_IF([enable_compiler_hardening],["yes"],
[
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
AC_CHECK_DECL([_FORTIFY_SOURCE],
[MHD_APPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-U_FORTIFY_SOURCE])],
[],[/* no includes */])
MHD_APPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-D_FORTIFY_SOURCE=2])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${user_CFLAGS}"
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac],[-fstack-protector-strong],[-fstack-protector-all],[-fstack-protector])
MHD_CHECK_ADD_CC_CFLAGS([-fstack-clash-protection],[CFLAGS_ac])
MHD_FIND_ADD_CC_CFLAG([CFLAGS_ac],[-ftrivial-auto-var-init=pattern],[-ftrivial-auto-var-init=zero])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
AS_IF([test "x${enable_static}" = "xyes" && test "x${pic_mode}" != "xyes"],
[
# PIE static lib can be used within non-PIE application, but
# PIE static lib cannot be used in non-PIE shared lib. Let's assume
# that static lib will not be used in shared lib
# All "pie" flags will be used automatically by libtool only
# for static library objects.
CFLAGS="${user_CFLAGS}"
# Perform tests here with "-pie" enabled
LDFLAGS="${LDFLAGS_ac} -pie ${user_LDFLAGS}"
MHD_CHECK_ADD_CC_CFLAG([-fPIE],[CFLAGS_ac],
[
MHD_APPEND_FLAG_TO_VAR([LDFLAGS_ac],[-pie])
],
[
MHD_CHECK_ADD_CC_CFLAG([-fpie],[CFLAGS_ac],
[
MHD_APPEND_FLAG_TO_VAR([LDFLAGS_ac],[-pie])
]
)
]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
# Linker hardening options
# Currently these options are ELF specific, they don't work on Darwin and W32
AC_ARG_ENABLE([linker-hardening],
[AS_HELP_STRING([--enable-linker-hardening], [enable linker security fixups])],
[],
[AS_CASE([${enable_build_type}],[*-hardened],
[enable_linker_hardening='yes'],[enable_linker_hardening='no'])]
)
AS_VAR_IF([enable_linker_hardening],["yes"],
[
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${user_LDFLAGS}"
MHD_CHECK_ADD_CC_LDFLAG([-Wl,-z,relro],[LDFLAGS_ac],
[MHD_CHECK_ADD_CC_LDFLAG([-Wl,-z,now],[LDFLAGS_ac])])
# Actually should be "noexec" by default, but let's try to enforce it.
MHD_CHECK_ADD_CC_LDFLAG([-Wl,-z,noexecstack],[LDFLAGS_ac])
# W32-specific. Some are enabled by default, but they will be enfored to be sure.
MHD_CHECK_ADD_CC_LDFLAGS([-Wl,--large-address-aware -Wl,--enable-auto-image-base],[LDFLAGS_ac])
MHD_CHECK_ADD_CC_LDFLAGS([-Wl,--dynamicbase -Wl,--nxcompat -Wl,--high-entropy-va],[LDFLAGS_ac])
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
AH_TEMPLATE([[HAVE_STDBOOL_H]], [Define to 1 i][f you have the <stdbool.h> header file and <stdbool.h> defines 'bool' type.])
AH_TEMPLATE([[HAVE_REAL_BOOL]], [Define to 1 i][f you have the real boolean type.])
AH_TEMPLATE([[bool]], [Define to type name which will be used as boolean type.])
AC_CHECK_HEADER([stdbool.h],
[
AC_CHECK_TYPE([bool],
[
AC_DEFINE([[HAVE_STDBOOL_H]], [[1]])
AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])
],
[
AC_MSG_WARN([[Header <stdbool.h> is present, but "bool" type cannot be detected. Check compiler flags.]])
AC_DEFINE([[bool]], [[int]])
], [
#include <stdbool.h>
]
)
],
[
AC_CHECK_TYPE([bool],
[AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])],
[
AC_CHECK_TYPE([_Bool],
[
AC_DEFINE([[HAVE_REAL_BOOL]], [[1]])
AC_DEFINE([[bool]], [[_Bool]])
],
[
AC_DEFINE([[bool]], [[int]])
], []
)
], []
)
],
[AC_INCLUDES_DEFAULT]
)
AC_CACHE_CHECK([[whether "true" is defined or builtin]], [[mhd_cv_macro_true_defined]],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif
]], [[
#if defined(true)
/* dummy */
#else
(void)true;
#endif
]])
], [[mhd_cv_macro_true_defined='yes']], [[mhd_cv_macro_true_defined='no']])
])
AS_VAR_IF([[mhd_cv_macro_true_defined]], [["yes"]], [[:]],
[AC_DEFINE([[true]],[[(!0)]], [Define to value interpreted by compiler as boolean "true", if "true" is not defined by system headers.])])
AC_CACHE_CHECK([[whether "false" is defined or builtin]], [[mhd_cv_macro_false_defined]],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif
]], [[
#if !defined(false)
(void)false;
#else
/* dummy */
#endif
]])
], [[mhd_cv_macro_false_defined='yes']], [[mhd_cv_macro_false_defined='no']])
])
AS_VAR_IF([[mhd_cv_macro_false_defined]], [["yes"]], [[:]],
[AC_DEFINE([[false]],[[0]], [Define to value interpreted by compiler as boolean "false", if "false" is not defined by system headers.])])
AC_CACHE_CHECK([[whether "true" and "false" could be used]], [[mhd_cv_macro_true_false_valid]],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif
]], [[
int var1[true ? 1 : -1] = { 1 };
int var2[false ? -1 : 1] = { 2 };
int var3[!true ? -1 : 1] = { 3 };
int var4[!false ? 1 : -1] = { 4 };
if (var1[0] == var2[0] || var3[0] == var4[0])
return 1;
]])
], [[mhd_cv_macro_true_false_valid='yes']], [[mhd_cv_macro_true_false_valid='no']])
])
AS_VAR_IF([[mhd_cv_macro_true_false_valid]], [["yes"]], [[:]],
[AC_MSG_ERROR([[Value of "true" or value of "false" is not valid. Check config.log for details.]])])
AX_CHECK_COMPILE_FLAG([[-Werror=attributes]],
[
AC_MSG_CHECKING([[whether -Werror=attributes actually works]])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS} -Werror=attributes"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
[[__attribute__((non_existing_attrb_dummy)) static int SimpleFunc(void) {return 3;}]],
[[int r = SimpleFunc(); if (r) return r;]])],
[
AC_MSG_RESULT([[no]])
errattr_CFLAGS=""
], [
AC_MSG_RESULT([[yes]])
errattr_CFLAGS="-Werror=attributes"
])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
],
[[errattr_CFLAGS=""]], [], [])
AC_MSG_CHECKING([[for function inline keywords supported by $CC]])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS} $errattr_CFLAGS"
inln_prfx="none"
# Prefer always inline functions
for inln_prfx_chk in InlineWithAttr __forceinline inline __inline__ __inline _inline _Inline
do
# Try to link to avoid "symbol undefined" problems at build time
AS_IF([[test "x$inln_prfx_chk" = "xInlineWithAttr"]],
[
AS_IF([[test "x$errattr_CFLAGS" = "x"]],
[[ # Skip test with attribute as negative result can't be detected
inln_prfx_chk="__forceinline" # use next value
]],[[inln_prfx_chk="inline __attribute__((always_inline))"]])
])
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef __cplusplus
#error This test is only for C.
choke me
#endif
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif
static $inln_prfx_chk bool cmpfn(int x, int y)
{ return x > y; }
static $inln_prfx_chk int sumfn(int x, int y)
{ return x + y; }
]],[[
int a = 1, b = 100, c;
if (cmpfn(a, b))
c = sumfn(a, b);
else
c = 0 - sumfn(a, b);
if (c)
return 0;
]])
],
[[ inln_prfx="$inln_prfx_chk" ]])
test "x$inln_prfx" != "xnone" && break
done
AS_IF([[test "x$inln_prfx" != "xnone"]],
[
AC_DEFINE([INLINE_FUNC],[1],[Define to 1 if your C compiler supports inline functions.])
AC_DEFINE_UNQUOTED([_MHD_static_inline],[static $inln_prfx],[Define to prefix which will be used with MHD static inline functions.])
], [
AC_DEFINE([_MHD_static_inline],[static],[Define to prefix which will be used with MHD static inline functions.])
])
AC_MSG_RESULT([[$inln_prfx]])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
AC_CHECK_HEADERS([stdalign.h], [], [], [AC_INCLUDES_DEFAULT])
AC_CACHE_CHECK([[for C11 'alignof()' support]], [[mhd_cv_c_alignof]],
[AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef HAVE_STDALIGN_H
#include <stdalign.h>
#endif
]], [[
int var1[(alignof(int) >= 2) ? 1 : -1];
int var2[alignof(unsigned int) - 1];
int var3[(alignof(char) > 0) ? 1 : -1];
int var4[(alignof(long) >= 4) ? 1 : -1];
/* Mute compiler warnings */
var1[0] = var2[0] = var3[0] = 0;
var4[0] = 1;
if (var1[0] + var2[0] + var3[0] == var4[0])
return 1;
]])
], [
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM(
[[
#ifdef HAVE_STDALIGN_H
#include <stdalign.h>
#endif
]], [[
/* Should fail if 'alignof()' works */
int var1[alignof(nonexisting_type) - 1];
/* Mute compiler warnings */
var1[0] = 1;
if (var1[0] + 1 == 1)
return 1;
]])
], [[mhd_cv_c_alignof='no']], [[mhd_cv_c_alignof='yes']])
], [[mhd_cv_c_alignof='no']])
])
AS_VAR_IF([mhd_cv_c_alignof], ["yes"],
[AC_DEFINE([[HAVE_C_ALIGNOF]], [1], [Define to 1 if your compiler supports 'alignof()'])])
# Check system type
AC_MSG_CHECKING([[for target host OS]])
AS_CASE(["$host_os"],
[*darwin* | *rhapsody* | *macosx*],
[AC_DEFINE([OSX],[1],[This is an OS X system])
mhd_host_os='Darwin'
AC_MSG_RESULT([[$mhd_host_os]])],
[kfreebsd*-gnu],
[AC_DEFINE([SOMEBSD],[1],[This is a BSD system])
AC_DEFINE([FREEBSD],[1],[This is a FreeBSD system])
mhd_host_os='FreeBSD kernel with GNU userland'
AC_MSG_RESULT([[$mhd_host_os]])],
[freebsd*],
[AC_DEFINE([SOMEBSD],[1],[This is a BSD system])
AC_DEFINE([FREEBSD],[1],[This is a FreeBSD system])
mhd_host_os='FreeBSD'
AC_MSG_RESULT([[$mhd_host_os]])],
[openbsd*],
[AC_DEFINE([SOMEBSD],[1],[This is a BSD system])
AC_DEFINE([OPENBSD],[1],[This is an OpenBSD system])
mhd_host_os='OpenBSD'
AC_MSG_RESULT([[$mhd_host_os]])],
[netbsd*],
[AC_DEFINE([SOMEBSD],[1],[This is a BSD system])
AC_DEFINE([NETBSD],[1],[This is a NetBSD system])
mhd_host_os='NetBSD'
AC_MSG_RESULT([[$mhd_host_os]])],
[*solaris*],
[AC_DEFINE([SOLARIS],[1],[This is a Solaris system])
AC_DEFINE([_REENTRANT],[1],[Need with solaris or errno does not work])
mhd_host_os='Solaris'
AC_MSG_RESULT([[$mhd_host_os]])],
[*linux*],
[AC_DEFINE([LINUX],[1],[This is a Linux kernel])
mhd_host_os='Linux'
AC_MSG_RESULT([[$mhd_host_os]])],
[*cygwin*],
[AC_DEFINE([CYGWIN],[1],[This is a Cygwin system])
mhd_host_os='Windows/Cygwin'
AC_MSG_RESULT([[$mhd_host_os]])
os_is_windows=yes],
[*mingw*],
[
AC_DEFINE([MINGW],[1],[This is a MinGW system])
AC_DEFINE([WINDOWS],[1],[This is a Windows system])
mhd_host_os='Windows/MinGW'
AC_MSG_RESULT([[$mhd_host_os]])
AC_CHECK_HEADERS([winsock2.h ws2tcpip.h], [], [AC_MSG_ERROR([[Winsock2 headers are required for W32]])], [AC_INCLUDES_DEFAULT])
AC_CACHE_CHECK([for MS lib utility], [ac_cv_use_ms_lib_tool],
[mslibcheck=`lib 2>&1`
AS_IF([echo "$mslibcheck" | $GREP -e '^Microsoft (R) Library Manager' - >/dev/null],
[ac_cv_use_ms_lib_tool=yes],
[ac_cv_use_ms_lib_tool=no])
])
AS_IF([test "x$ac_cv_use_ms_lib_tool" = "xyes"],
[AC_SUBST([MS_LIB_TOOL], [[lib]])])
AC_SUBST([lt_cv_objdir])
os_is_windows=yes
os_is_native_w32=yes
],
[*openedition*],
[AC_DEFINE([OS390],[1],[This is a OS/390 system])
mhd_host_os='OS/390'
AC_MSG_RESULT([[$mhd_host_os]])],
[gnu*],
[AC_DEFINE([[GNU_HURD]], [[1]], [Define to `1' if host machine runs on GNU Hurd.])
mhd_host_os='GNU Hurd'
AC_MSG_RESULT([[$mhd_host_os]])
],
[
AC_MSG_RESULT([unrecognised OS])
mhd_host_os="${host_os}"
AC_MSG_WARN([Unrecognised OS $host_os])
AC_DEFINE([OTHEROS],1,[Some strange OS])
])
AM_CONDITIONAL([CYGWIN_TARGET], [[test "x$os_is_windows" = "xyes" && \
test "x${os_is_native_w32}" != "xyes"]])
AS_VAR_IF([os_is_windows], ["yes"],
[
AC_MSG_CHECKING([[whether target W32 version is specified by precompiler defines]])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
/* Note: check logic is reversed for easy log reading */
#ifdef WINVER
#error WINVER is defined
choke me now;
#endif
#ifdef _WIN32_WINNT
#error _WIN32_WINNT is defined
choke me now;
#endif
#ifdef NTDDI
#error NTDDI is defined
choke me now;
#endif
]],[[(void)0]])
], [[mhd_w32_ver_preselect=no]], [[mhd_w32_ver_preselect=yes]]
)
AC_MSG_RESULT([[${mhd_w32_ver_preselect}]])
AC_CHECK_HEADERS([windows.h sdkddkver.h], [], [], [AC_INCLUDES_DEFAULT])
AS_VAR_IF([mhd_w32_ver_preselect],["yes"],
[
AC_MSG_CHECKING([[for specified target W32 version]])
AS_UNSET([[mhd_w32_ver]])
AS_UNSET([[mhd_w32_ver_msg]])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#if _WIN32_WINNT+0 < 0x0501
/* Check before headers inclusion */
#error _WIN32_WINNT is less than 0x0501
choke me now;
#endif
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#if _WIN32_WINNT+0 < 0x0501
#error _WIN32_WINNT is less than 0x0501
choke me now;
#endif
]],[[(void)0]])
], [], [
AC_MSG_RESULT([[pre-WinXP]])
AC_MSG_ERROR([[libmicrohttpd cannot be compiled for Windows version before Windows XP]])
]
)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#if _WIN32_WINNT+0 == 0x0501
#error _WIN32_WINNT is 0x0501
choke me now;
#endif
#if _WIN32_WINNT+0 == 0x0502
#error _WIN32_WINNT is 0x0502
choke me now;
#endif
]],[[(void)0]])
], [], [
mhd_w32_ver="WinXP"
mhd_w32_ver_msg="WinXP (selected by precompiler flags)"
]
)
AS_VAR_SET_IF([mhd_w32_ver], [],
[
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#if _WIN32_WINNT+0 < 0x0600
#error _WIN32_WINNT is less than 0x0600 but greater than 0x0502
choke me now;
#endif
]],[[(void)0]])
], [], [
AC_MSG_ERROR([[_WIN32_WINNT value is wrong (less than 0x0600 but greater than 0x0502)]])
]
)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#if _WIN32_WINNT+0 == 0x0600
#error _WIN32_WINNT is 0x0600
choke me now;
#endif
]],[[(void)0]])
], [], [
mhd_w32_ver="Vista"
mhd_w32_ver_msg="Vista (selected by precompiler flags)"
]
)
]
)
AS_VAR_SET_IF([mhd_w32_ver], [],
[
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#if _WIN32_WINNT+0 > 0x0600
#error _WIN32_WINNT is greater than 0x0600
choke me now;
#endif
]],[[(void)0]])
], [
mhd_w32_ver="unknown"
mhd_w32_ver_msg="unknown (cannot be detected)"
], [
mhd_w32_ver="newer than Vista"
mhd_w32_ver_msg="newer than Vista (selected by precompiler flags)"
]
)
]
)
AC_MSG_RESULT([[${mhd_w32_ver}]])
], [
mhd_w32_ver="Vista"
mhd_w32_ver_msg="Vista (default, override by CPPFLAGS=-D_WIN32_WINNT=0xNNNN)"
CPPFLAGS_ac="${CPPFLAGS_ac} -D_WIN32_WINNT=0x0600"
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
AC_MSG_CHECKING([[whether headers accept _WIN32_WINNT=0x0600]])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#ifdef HAVE_SDKDDKVER_H
#include <sdkddkver.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#include <stdio.h>
]],[[(void)0]])
], [
AC_MSG_RESULT([[yes]])
], [
AC_MSG_RESULT([[no]])
AC_MSG_ERROR([Headers do not accept _WIN32_WINNT=0x0600. Consider override target W32 version by CPPFLAGS=-D_WIN32_WINNT=0xNNNN])
]
)
]
)
]
)
AS_IF([test "x${os_is_windows}" = "xyes" && test "x${os_is_native_w32}" = "xyes"],
[
AC_CACHE_CHECK([W32 run-time library type], [mhd_cv_wctr_type],
[
AC_EGREP_CPP([MHDMARKER: UCRT run-time library in use!], [
#include <stdio.h>
#if defined(_UCRT)
#define CRT_STR "MHDMARKER: UCRT run-time library in use!"
#endif
#if defined(__MSVCRT_VERSION__)
#if (__MSVCRT_VERSION__ >= 0xE00) && (__MSVCRT_VERSION__ < 0x1000)
#define CRT_STR "MHDMARKER: UCRT run-time library in use!"
#endif
#if (__MSVCRT_VERSION__ > 0x1400)
#define CRT_STR "MHDMARKER: UCRT run-time library in use!"
#endif
#endif
#ifndef CRT_STR
#define CRT_STR "MHDMARKER: MSVCRT run-time library in use!"
#endif
int main(void)
{
printf ("%\n", CRT_STR);
return 0;
}
],
[mhd_cv_wctr_type="ucrt"], [mhd_cv_wctr_type="msvcrt"])
]
)
mhd_host_os="${mhd_host_os}-${mhd_cv_wctr_type}"
AS_VAR_IF([mhd_cv_wctr_type], ["msvcrt"],
[
# Use CFLAGS here to override user-supplied wrong CPPFLAGS. Durty trick, but choice is limited.
AX_APPEND_COMPILE_FLAGS([-U__USE_MINGW_ANSI_STDIO -D__USE_MINGW_ANSI_STDIO=0], [CFLAGS_ac])
AC_SUBST([W32CRT], [MSVCRT])
], [AC_SUBST([W32CRT], [UCRT])]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${user_LDFLAGS}"
AS_CASE([$mhd_w32_ver],
[WinXP],
[MHD_CHECK_ADD_CC_LDFLAG([-Wl,--major-subsystem-version,5,--minor-subsystem-version,1],[LDFLAGS_ac])],
[Vista],
[MHD_CHECK_ADD_CC_LDFLAG([-Wl,--major-subsystem-version,6,--minor-subsystem-version,0],[LDFLAGS_ac])]
)
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
AC_ARG_WITH([threads],
[AS_HELP_STRING([--with-threads=LIB],[choose threading library (posix, w32, auto, none) [auto]])],
[], [with_threads='auto'])
AS_CASE([[$with_threads]],
[[win32]], [[with_threads='w32']],
[[pthreads]], [[with_threads='posix']],
[[posix]], [[:]],
[[w32]], [[:]],
[[none]], [[with_threads='none']],
[[no]], [[with_threads='none']],
[[auto]], [[:]],
[AC_MSG_ERROR([[incorrect parameter "$with_threads" specified for --with-threads]])]
)
# Check for posix threads support, regardless of configure parameters as
# testsuite uses only posix threads.
AX_PTHREAD(
[
mhd_have_posix_threads='yes'
AC_DEFINE([[HAVE_PTHREAD_H]],[[1]],[Define to 1 if you have the <pthread.h> header file.])
AC_CACHE_CHECK([[whether pthread_sigmask(3) is available]],
[[mhd_cv_func_pthread_sigmask]], [dnl
save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="${CFLAGS_ac} ${PTHREAD_CFLAGS} ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <signal.h>]],
[[
sigset_t nset, oset;
sigemptyset (&nset);
sigaddset (&nset, SIGPIPE);
if (0 != pthread_sigmask(SIG_BLOCK, &nset, &oset)) return 1;
]])],
[[mhd_cv_func_pthread_sigmask="yes"]],[[mhd_cv_func_pthread_sigmask="no"]])
LIBS="${save_LIBS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
])
AS_VAR_IF([mhd_cv_func_pthread_sigmask],["yes"],
[AC_DEFINE([[HAVE_PTHREAD_SIGMASK]],[[1]],[Define to 1 if you have the pthread_sigmask(3) function.])])
],[[mhd_have_posix_threads='no']])
AM_CONDITIONAL([HAVE_POSIX_THREADS],[test "x$mhd_have_posix_threads" = "xyes"])
mhd_have_w32_threads='no'
AS_IF([[test "x$with_threads" = "xauto"]],
[
AS_IF([[test "x$os_is_windows" = "xyes"]],
[
AC_MSG_CHECKING([[for W32 threads]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <windows.h>
]], [ HANDLE h = CreateThread(NULL, 0, NULL, NULL, 0, NULL);])]
, [[mhd_have_w32_threads='yes']], [[mhd_have_w32_threads='no']]
)
AC_MSG_RESULT([[$mhd_have_w32_threads]])
])
]
)
AC_MSG_CHECKING([[for threading lib to use with libmicrohttpd ($with_threads)]])
AS_IF([test "x$with_threads" = "xposix"],
[ # forced posix threads
AS_IF([test "x$mhd_have_posix_threads" = "xyes"], [USE_THREADS='posix'],
[ AS_IF([[test "x$os_is_windows" = "xyes"]] ,
[ AC_MSG_ERROR([[Posix threads are not available. Try to configure --with-threads=auto]])],
[ AC_MSG_ERROR([[No threading lib is available. Consider installing pthreads]])] )
])
])
AS_IF([test "x$with_threads" = "xw32"],
[ # forced w32 threads
AS_IF([[test "x$mhd_have_w32_threads" = "xyes"]],
[[ USE_THREADS='w32' ]],
[ AC_MSG_ERROR([[W32 threads are not available. Try to configure --with-threads=auto]])])
])
AS_IF([test "x$with_threads" = "xauto"],
[# automatic threads lib selection
AS_IF([[test "x$os_is_native_w32" = "xyes" && test "x$mhd_have_w32_threads" = "xyes"]] ,
[[ USE_THREADS='w32' ]] ,
[[ test "x$mhd_have_posix_threads" = "xyes" ]], [[ USE_THREADS='posix' ]],
[[ test "x$mhd_have_w32_threads" = "xyes" ]], [[ USE_THREADS='w32' ]],
[ AC_MSG_ERROR([[No threading lib is available. Consider installing pthreads]]) ]
)])
AS_IF([test "x$with_threads" = "xnone"],
[USE_THREADS='none'])
AS_IF([test "x$USE_THREADS" = "xposix"],
[CC="$PTHREAD_CC"
AC_DEFINE([MHD_USE_POSIX_THREADS],[1],[define to use pthreads])
MHD_LIB_CFLAGS="$MHD_LIB_CFLAGS $PTHREAD_CFLAGS"
MHD_LIBDEPS="$PTHREAD_LIBS $MHD_LIBDEPS"
MHD_LIBDEPS_PKGCFG="$PTHREAD_LIBS $MHD_LIBDEPS_PKGCFG"],
[AS_IF([test "x$USE_THREADS" = "xw32"],
[AC_DEFINE([MHD_USE_W32_THREADS],[1],[define to use W32 threads])])])
AM_CONDITIONAL([USE_POSIX_THREADS], [test "x$USE_THREADS" = "xposix"])
AM_CONDITIONAL([USE_W32_THREADS], [test "x$USE_THREADS" = "xw32"])
AM_CONDITIONAL([USE_THREADS], [test "x$USE_THREADS" != "xnone"])
AM_CONDITIONAL([DISABLE_THREADS], [test "x$USE_THREADS" = "xnone"])
AC_MSG_RESULT([$USE_THREADS])
AC_ARG_ENABLE([[thread-names]],
[AS_HELP_STRING([--disable-thread-names],[do not set names on MHD generated threads [auto]])],
[], [enable_thread_names='auto'])
AS_IF([test "x$enable_thread_names" != "xno" && test "x$USE_THREADS" = "xposix"],[
# Check for thread name function
HAVE_THREAD_NAME_FUNC="no"
SAVE_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="${CFLAGS_ac} $PTHREAD_CFLAGS ${user_CFLAGS}"
AC_CHECK_HEADERS([pthread_np.h],[],[],
[
AC_INCLUDES_DEFAULT
[
#include <pthread.h>
]
])
# Try to find how to set thread name by thread attributes.
# If pthread_attr_setname_np(3) is not declared, it's not possible to detect
# form of pthread_attr_setname_np(3) due to C "feature" "implicit declaration".
AC_CHECK_DECL([[pthread_attr_setname_np]],[],[],[[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]])
AS_IF([[test "x$ac_cv_have_decl_pthread_attr_setname_np" = "xyes"]],
[AC_MSG_CHECKING([[for pthread_attr_setname_np(3) in NetBSD or OSF1 form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[
pthread_attr_t thr_attr;
pthread_attr_init(&thr_attr);
pthread_attr_setname_np(&thr_attr, "name", 0);
pthread_attr_destroy(&thr_attr);
]])],
[AC_DEFINE([[HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD]], [[1]], [Define if you have NetBSD form (or OSF1 form) of pthread_attr_setname_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
])
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_attr_setname_np" = "xyes"]],
[AC_MSG_CHECKING([[for pthread_attr_setname_np(3) in IBM i or Solaris form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[
pthread_attr_t thr_attr;
pthread_attr_init(&thr_attr);
pthread_attr_setname_np(&thr_attr, "name");
pthread_attr_destroy(&thr_attr);
]])],
[AC_DEFINE([[HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI]], [[1]], [Define if you have IBM i form (or Solaris form) of pthread_attr_setname_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
])
# Try to find how to set thread name for started thread - less convenient
# than setting name by attributes.
# If pthread_setname_np(3) is not declared, it's not possible to detect
# form of pthread_setname_np(3) due to C "feature" "implicit declaration".
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes"]],
[AC_CHECK_DECL([[pthread_setname_np]],[],[],[[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]])
])
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],
[AC_MSG_CHECKING([[for pthread_setname_np(3) in NetBSD or OSF1 form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[int res = pthread_setname_np(pthread_self(), "name", 0); if (res) return res;]])],
[AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_NETBSD]], [[1]], [Define if you have NetBSD form (or OSF1 form) of pthread_setname_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
])
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],
[AC_MSG_CHECKING([[for pthread_setname_np(3) in GNU/Linux form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[int res = pthread_setname_np(pthread_self(), "name"); if (res) return res;]])],
[AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_GNU]], [[1]], [Define if you have GNU/Linux form of pthread_setname_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
])
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes" && test "x$ac_cv_have_decl_pthread_setname_np" = "xyes"]],
[AC_MSG_CHECKING([[for pthread_setname_np(3) in Darwin form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[int res = pthread_setname_np("name"); if (res) return res;]])],
[AC_DEFINE([[HAVE_PTHREAD_SETNAME_NP_DARWIN]], [[1]], [Define if you have Darwin form of pthread_setname_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
])
AS_IF([[test "x$HAVE_THREAD_NAME_FUNC" != "xyes"]],
[
AC_CHECK_DECL([[pthread_set_name_np]],
[
AC_MSG_CHECKING([[for pthread_set_name_np(3) in FreeBSD form]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]], [[pthread_set_name_np(pthread_self(), "name");]])],
[AC_DEFINE([[HAVE_PTHREAD_SET_NAME_NP_FREEBSD]], [[1]], [Define if you have FreeBSD form of pthread_set_name_np(3) function.])
HAVE_THREAD_NAME_FUNC="yes"
AC_MSG_RESULT([[yes]])],
[AC_MSG_RESULT([[no]])]
)
],[],[[
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
]]
)
])
LIBS="$SAVE_LIBS"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
])
AS_IF([[test "x$enable_thread_names" != "xno"]],
[
AC_MSG_CHECKING([[whether to enable thread names]])
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM([], [[
#ifdef MHD_NO_THREAD_NAMES
#error Thread names are disabled.
choke me
#endif
/* Keep in sync with mhd_threads.h */
#if defined(MHD_USE_POSIX_THREADS) && (defined(HAVE_PTHREAD_ATTR_SETNAME_NP_NETBSD) || defined(HAVE_PTHREAD_ATTR_SETNAME_NP_IBMI) || \
defined(HAVE_PTHREAD_SETNAME_NP_GNU) || defined(HAVE_PTHREAD_SET_NAME_NP_FREEBSD) || defined(HAVE_PTHREAD_SETNAME_NP_DARWIN) || \
defined(HAVE_PTHREAD_SETNAME_NP_NETBSD) )
(void) 0; /* no-op */
#elif defined(MHD_USE_W32_THREADS) && defined(_MSC_FULL_VER)
(void) 0; /* no-op */
#else
#error No thread name function is available.
choke me
#endif
]])
], [
enable_thread_names='yes'
], [
AS_IF([[test "x$enable_thread_names" = "xyes"]],
[
AC_MSG_RESULT([[no]])
AC_MSG_ERROR([[thread names was explicitly requested, but thread name function is not available]])
])
enable_thread_names='no'
])
AC_MSG_RESULT([[$enable_thread_names]])
])
AS_IF([[test "x$enable_thread_names" = "xno"]],
[AC_DEFINE([[MHD_NO_THREAD_NAMES]], [[1]], [Define to 1 to disable setting name on generated threads])])
AM_CONDITIONAL(HAVE_W32, [test "x$os_is_native_w32" = "xyes"])
w32_shared_lib_exp=no
AS_IF([test "x$enable_shared" = "xyes" && test "x$os_is_native_w32" = "xyes"],
[
AS_IF([test "x$ac_cv_use_ms_lib_tool" = "xyes" || test -n "$DLLTOOL"],
[
w32_shared_lib_exp=yes
use_expfile="no"
AS_VAR_IF([ac_cv_use_ms_lib_tool], ["yes"], [use_expfile="yes"],
[
AC_CACHE_CHECK([whether $DLLTOOL supports export file generation], [mhd_cv_dlltool_expfile],
[
AS_IF([AC_RUN_LOG([$DLLTOOL -e conftest.exp >&2 ])],
[
AS_IF([test -f conftest.exp], [mhd_cv_dlltool_expfile="yes"], [mhd_cv_dlltool_expfile="no"])
], [mhd_cv_dlltool_expfile="no"]
)
rm -f conftest.exp
]
)
use_expfile="${mhd_cv_dlltool_expfile}"
]
)
],
[
AC_MSG_WARN([[GNU dlltool or MS lib.exe is required for creating shared library export on W32]])
AC_MSG_WARN([[Export library libmicrohttpd.lib will not be created]])
]
)
]
)
AM_CONDITIONAL([W32_SHARED_LIB_EXP], [test "x$w32_shared_lib_exp" = "xyes"])
AM_CONDITIONAL([USE_MS_LIB_TOOL], [test "x$ac_cv_use_ms_lib_tool" = "xyes"])
AM_CONDITIONAL([USE_EXPORT_FILE], [test "x$use_expfile" = "xyes"])
dnl gethostbyname() is not really needed
dnl AC_SEARCH_LIBS([gethostbyname], [nsl])
MHD_FIND_LIB([socket],
[[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_SOCKLIB_H
#include <sockLib.h>
#endif
#if defined(_WIN32) && ! defined(__CYGWIN__)
#include <winsock2.h>
#endif
]],
[(void)socket(0, 0, 0);],
[socket ws2_32 xnet],
[
AS_VAR_IF([[mhd_cv_find_lib_socket]],[["none required"]], [],
[
MHD_LIBDEPS_PKGCFG="${mhd_cv_find_lib_socket} $MHD_LIBDEPS_PKGCFG"
]
)
],
[AC_MSG_ERROR([[cannot find header or library required for function socket()]])]
)
MHD_CHECK_SOCKET_SHUTDOWN_TRIGGER([AC_DEFINE([HAVE_LISTEN_SHUTDOWN],[1],[can use shutdown on listen sockets])])
AM_CONDITIONAL([HAVE_LISTEN_SHUTDOWN], [test "x$mhd_cv_host_shtdwn_trgr_select" = "xyes"])
MHD_CHECK_FUNC([writev],
[[#include <sys/uio.h>]],
[[
struct iovec iov[2];
char some_str[4] = "OK\n";
iov[0].iov_base = (void *) some_str;
iov[0].iov_len = 3;
i][f (0 > writev(1, iov, 1))
return 2;
]]
)
MHD_FIND_LIB([sendmsg],
[[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_SOCKLIB_H
#include <sockLib.h>
#endif
#ifdef HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
]],
[[
struct msghdr msg;
struct iovec iov;
unsigned int i;
char some_str[5] = "test";
iov.iov_base = (void*)some_str;
iov.iov_len = 4;
for (i = 0; i < (unsigned int) sizeof(msg); i++)
{
*(((unsigned char *)&msg) + i) = 0;
}
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
i][f (0 > sendmsg(1, &msg, 0))
return -1;
]],
[socket],
[
AC_DEFINE([HAVE_SENDMSG],[1],[Define to '1' if your have sendmsg() function])
AS_VAR_IF([[mhd_cv_find_lib_sendmsg]],[["none required"]], [],
[
MHD_LIBDEPS_PKGCFG="${mhd_cv_find_lib_sendmsg} $MHD_LIBDEPS_PKGCFG"
]
)
],[],
[MHD_LIBDEPS]
)
AC_C_BIGENDIAN
AC_C_VARARRAYS
AC_CACHE_CHECK([[whether __func__ magic-macro is available]],
[[mhd_cv_macro___func___avail]], [dnl
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stddef.h>]],[[const char *funcname = __func__ ; if (NULL == funcname) return 1;]])],
[[mhd_cv_macro___func___avail="yes"]],[[mhd_cv_macro___func___avail="no"]])
])
AS_VAR_IF([mhd_cv_macro___func___avail], ["yes"],
[AC_DEFINE([HAVE___FUNC__], [1], [Define to 1 if your compiler supports __func__ magic-macro.])],
[
AC_CACHE_CHECK([[whether __FUNCTION__ magic-macro is available]],
[[mhd_cv_macro___function___avail]], [dnl
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <stddef.h>]],[[const char *funcname = __FUNCTION__ ; if (NULL == funcname) return 1;]])],
[[mhd_cv_macro___function___avail="yes"]],[[mhd_cv_macro___function___avail="no"]])
])
AC_DEFINE([HAVE___FUNCTION__], [1], [Define to 1 if your compiler supports __FUNCTION__ magic-macro.])
]
)
AC_CACHE_CHECK([[whether __builtin_bswap32() is available]],
[[mhd_cv_func___builtin_bswap32_avail]], [dnl
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include<stdint.h>]], [[uint32_t a = 1; uint32_t b = __builtin_bswap32(a); a = b; (void) a;]])],
[[mhd_cv_func___builtin_bswap32_avail="yes"]],[[mhd_cv_func___builtin_bswap32_avail="no"]])
])
AS_IF([[test "x$mhd_cv_func___builtin_bswap32_avail" = "xyes"]],
[AC_DEFINE([[MHD_HAVE___BUILTIN_BSWAP32]], [[1]], [Define to 1 if you have __builtin_bswap32() builtin function])])
AC_CACHE_CHECK([[whether __builtin_bswap64() is available]],
[[mhd_cv_func___builtin_bswap64_avail]], [dnl
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include<stdint.h>]], [[uint64_t a = 1; uint64_t b = __builtin_bswap64(a); a = b; (void) a;]])],
[[mhd_cv_func___builtin_bswap64_avail="yes"]], [[mhd_cv_func___builtin_bswap64_avail="no"]])
])
AS_IF([[test "x$mhd_cv_func___builtin_bswap64_avail" = "xyes"]],
[AC_DEFINE([[MHD_HAVE___BUILTIN_BSWAP64]], [[1]], [Define to 1 if you have __builtin_bswap64() builtin function])])
AC_CHECK_PROG([HAVE_CURL_BINARY],[curl],[yes],[no])
AM_CONDITIONAL([HAVE_CURL_BINARY],[test "x$HAVE_CURL_BINARY" = "xyes"])
AC_CHECK_PROG([HAVE_MAKEINFO_BINARY],[makeinfo],[yes],[no])
AM_CONDITIONAL([HAVE_MAKEINFO_BINARY],[test "x$HAVE_MAKEINFO_BINARY" = "xyes"])
AM_CONDITIONAL(W32_STATIC_LIB, [test "x$os_is_native_w32" = "xyes" && test "x$enable_static" = "xyes"])
AC_ARG_ENABLE([[doc]],
[AS_HELP_STRING([[--disable-doc]], [do not build any documentation])], ,
[enable_doc=yes])
test "x$enable_doc" = "xno" || enable_doc=yes
AM_CONDITIONAL([BUILD_DOC], [test "x$enable_doc" = "xyes"])
AC_ARG_ENABLE([[examples]],
[AS_HELP_STRING([[--disable-examples]], [do not build any examples])], ,
[enable_examples=yes])
test "x$enable_examples" = "xno" || enable_examples=yes
AM_CONDITIONAL([BUILD_EXAMPLES], [test "x$enable_examples" = "xyes"])
AC_ARG_ENABLE([[heavy-tests]],
[AS_HELP_STRING([[--enable-heavy-tests[=SCOPE]]], [use SCOPE of heavy tests in test-suite. WARNING:]
[a dedicated host with minimal number of background processes and no network]
[activity is recommended to enable. (basic, full)])], [],
[enable_heavy_tests=no])
use_heavy_tests="no"
use_vheavy_tests="no"
use_heavy_tests_MSG="no"
AS_CASE([${enable_heavy_tests}],
[yes|basic],
[
enable_heavy_tests="basic"
use_heavy_tests="yes"
use_vheavy_tests="no"
use_heavy_tests_MSG="yes, basic heavy tests (a dedicated host is recommended)"
],
[all|full],
[
enable_heavy_tests="full"
use_heavy_tests="yes"
use_vheavy_tests="yes"
use_heavy_tests_MSG="yes, full set of heavy tests (a dedicated host is recommended)"
],
[no],
[
use_heavy_tests="no"
use_vheavy_tests="no"
use_heavy_tests_MSG="no"
],
[AC_MSG_ERROR([[Unknown parameter value: --enable-heavy-tests=${enable_heavy_tests}]])]
)
AS_VAR_IF([use_heavy_tests], ["yes"],
[
HEAVY_TESTS_NOTPARALLEL='.NOTPARALLEL:'
AC_DEFINE([_MHD_HEAVY_TESTS], [1], [Define to 1 to enable "heavy" test paths.])
AS_VAR_IF([use_vheavy_tests], ["yes"],
[AC_DEFINE([_MHD_VHEAVY_TESTS], [1], [Define to 1 to enable "very heavy" test paths.])]
)
],
[
HEAVY_TESTS_NOTPARALLEL=" "
]
)
AM_CONDITIONAL([HEAVY_TESTS],[test "x$use_heavy_tests" = "xyes"])
AC_ARG_ENABLE([[poll]],
[AS_HELP_STRING([[--enable-poll[=ARG]]], [enable poll support (yes, no, auto) [auto]])],
[enable_poll=${enableval}],
[enable_poll='auto']
)
AS_IF([test "$enable_poll" != "no"],
[
AS_IF([test "$os_is_native_w32" != "yes"],
[
AC_CHECK_HEADERS([poll.h],
[
MHD_CHECK_FUNC([poll],
[[
#include <poll.h>
]],
[[
struct pollfd fds[2];
fds[0].fd = 0;
fds[0].events = POLLIN;
if (0 > poll(fds, 1, 0))
return 2;
]],
[have_poll='yes'], [have_poll='no']
)
], [], [AC_INCLUDES_DEFAULT]
)
],
[
MHD_CHECK_FUNC([WSAPoll],
[[
#include <winsock2.h>
]],
[[
WSAPOLLFD fda[2];
WSAPoll(fda, 2, 0);
]],
[
have_poll='yes'
AC_DEFINE([HAVE_POLL],[1])
],
[have_poll='no']
)
]
)
AS_IF([test "$enable_poll" = "yes" && test "$have_poll" != "yes"],
[AC_MSG_ERROR([[Support for poll was explicitly requested but cannot be enabled on this platform.]])])
enable_poll="$have_poll"
]
)
AC_ARG_ENABLE([[epoll]],
[AS_HELP_STRING([[--enable-epoll[=ARG]]], [enable epoll support (yes, no, auto) [auto]])],
[enable_epoll=${enableval}],
[enable_epoll='auto']
)
AS_IF([test "$enable_epoll" != "no"],
[
AX_HAVE_EPOLL
AS_IF([test "${ax_cv_have_epoll}" = "yes"],
[
AC_DEFINE([[EPOLL_SUPPORT]],[[1]],[Define to 1 to enable epoll support])
enable_epoll='yes'
],
[
AS_IF([test "$enable_epoll" = "yes"],
[AC_MSG_ERROR([[Support for epoll was explicitly requested but cannot be enabled on this platform.]])]
)
enable_epoll='no'
]
)
]
)
AM_CONDITIONAL([MHD_HAVE_EPOLL], [[test "x$enable_epoll" = xyes]])
AS_IF([test "x$enable_epoll" = "xyes"],
[
MHD_CHECK_FUNC([epoll_create1],
[[
#include <sys/epoll.h>
]],
[[
i][f (0 > epoll_create1(EPOLL_CLOEXEC))
return 3;
]]
)
]
)
AC_CACHE_CHECK([for supported 'noreturn' keyword], [mhd_cv_decl_noreturn],
[
mhd_cv_decl_noreturn="none"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS} ${errattr_CFLAGS}"
for decl_noret in '_Noreturn' '__attribute__((__noreturn__))' '__declspec(noreturn)'
do
AC_LINK_IFELSE([AC_LANG_SOURCE(
[[
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
${decl_noret} static void myexitfunc(int code)
{
#ifdef HAVE_STDLIB_H
exit (code);
#else
(void)code;
#endif
}
int main (int argc, char *const *argv)
{
(void) argv;
if (argc > 2)
myexitfunc (2);
return 0;
}
]]
)], [mhd_cv_decl_noreturn="${decl_noret}"]
)
AS_IF([test "x${mhd_cv_decl_noreturn}" != "xnone"], [break])
done
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
AS_VAR_IF([mhd_cv_decl_noreturn], ["none"],
[AC_DEFINE([_MHD_NORETURN], [], [Define to supported 'noreturn' function declaration])],
[AC_DEFINE_UNQUOTED([_MHD_NORETURN], [${mhd_cv_decl_noreturn}], [Define to supported 'noreturn' function declaration])]
)
# Check for types sizes
# Types sizes are used as an indirect indication of maximum allowed values for types
# which is used to exclude by preprocessor some compiler checks for values clips
# Assuming no staffing or uniform staffing for integer types
AC_CACHE_CHECK([size of tv_sec member of struct timeval], [mhd_cv_size_timeval_tv_sec],
[
AC_COMPUTE_INT([mhd_cv_size_timeval_tv_sec], [((long int)sizeof(test_var.tv_sec))],
[[
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif /* HAVE_SYS_TIME_H */
#ifdef HAVE_TIME_H
#include <time.h>
#endif /* HAVE_TIME_H */
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif /* HAVE_SYS_TYPES_H */
struct timeval test_var;
]],
[
# The size is used only to exclude additional checks/comparison in code
# to avoid compiler warnings. With larger size MHD code will use
# additional checks which ensure that value will fit but it may produce
# a harmless compiler warning.
AC_MSG_WARN([The size cannot be determined, assuming 8.])
mhd_cv_size_timeval_tv_sec=8
]
)
]
)
AC_DEFINE_UNQUOTED([SIZEOF_STRUCT_TIMEVAL_TV_SEC], [$mhd_cv_size_timeval_tv_sec],
[The size of `tv_sec' member of `struct timeval', as computed by sizeof])
AC_CHECK_SIZEOF([int64_t], [], [[#include <stdint.h>]])
AC_CHECK_SIZEOF([uint64_t], [], [[#include <stdint.h>]])
AC_CHECK_SIZEOF([int], [], [[#include <stdint.h>]])
AC_CHECK_SIZEOF([unsigned int], [], [[#include <stdint.h>]])
AC_CHECK_SIZEOF([unsigned long long], [], [[#include <stdint.h>]])
AC_CHECK_SIZEOF([size_t], [],
[[
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif /* HAVE_STDLIB_H */
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif /* HAVE_STDDEF_H */
#include <stdio.h>
]]
)
AC_CHECK_HEADERS([dlfcn.h],[have_tlsplugin=yes],[have_tlsplugin=no], [AC_INCLUDES_DEFAULT])
AM_CONDITIONAL([MHD_HAVE_TLS_PLUGIN], [[test "x$have_tlsplugin" = xyes]])
AC_CHECK_HEADERS([zlib.h],[have_zlib=yes],[have_zlib=no], [AC_INCLUDES_DEFAULT])
AM_CONDITIONAL([HAVE_ZLIB], [[test "x$have_zlib" = xyes]])
# Check for generic functions
MHD_CHECK_FUNC([random],
[
AC_INCLUDES_DEFAULT
[#include <stdlib.h>
]],
[[long int r = random(); (void)r;]],
[],
[
MHD_CHECK_FUNC([rand],
[
AC_INCLUDES_DEFAULT
[#include <stdlib.h>
]],
[[int r = rand(); (void)r;]],
)
]
)
AC_CHECK_MEMBERS([struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len,
struct sockaddr_storage.ss_len],
[], [],
[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
])
MHD_CHECK_LINK_RUN([[f][or working getsockname()]],[[mhd_cv_getsockname_usable]],
[[mhd_cv_getsockname_usable='assuming yes']],
[
AC_LANG_SOURCE(
[[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_WINSOCK2_H
#include <winsock2.h>
#endif
#ifdef HAVE_WS2TCPIP_H
#include <ws2tcpip.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_NETINET_IP_H
#include <netinet/ip.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
static void zr_mem(void *ptr, socklen_t size)
{ char *mem = ptr; while(size--) {mem[0] = 0; mem++;} }
int main(void)
{
const socklen_t c_addr_size = (socklen_t)sizeof(struct sockaddr_in);
struct sockaddr_in sa;
socklen_t addr_size;
int ret = 1;
#if !defined(_WIN32) || defined(__CYGWIN__)
int sckt;
const int invld_sckt = -1;
#else
SOCKET sckt;
const SOCKET invld_sckt = INVALID_SOCKET;
WSADATA wsa_data;
if (0 != WSAStartup(MAKEWORD(2, 2), &wsa_data) || MAKEWORD(2, 2) != wsa_data.wVersion)
return 20;
#endif
sckt = socket (PF_INET, SOCK_STREAM, 0);
if (invld_sckt != sckt)
{
zr_mem(&sa, c_addr_size);
sa.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
sa.sin_len = c_addr_size;
#endif
if (0 == bind (sckt, (struct sockaddr *)&sa, c_addr_size))
{
if (0 == listen (sckt, 1))
{
addr_size = c_addr_size;
if (0 == getsockname (sckt, (struct sockaddr *)&sa, &addr_size))
{
if (c_addr_size >= addr_size)
{
if (0 != ntohs(sa.sin_port))
{ ret = 0;
} else ret = 7;
} else ret = 6;
} else ret = 5;
} else ret = 4;
} else ret = 3;
} else ret = 2;
#if !defined(_WIN32) || defined(__CYGWIN__)
close (sckt);
#else
closesocket (sckt);
WSACleanup();
#endif
return ret;
}
]]
)
],
[AC_DEFINE([[MHD_USE_GETSOCKNAME]], [[1]], [Define if you have usable `getsockname' function.])]
)
AC_CACHE_CHECK([for usable PAGESIZE macro], [mhd_cv_macro_pagesize_usable],
[
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifndef PAGESIZE
#error No PAGESIZE macro defined
choke me now
#endif
]],
[[
long pgsz = PAGESIZE + 0;
if (1 > pgsz) return 1;
]]
)
],
[[mhd_cv_macro_pagesize_usable="yes"]], [[mhd_cv_macro_pagesize_usable="no"]]
)
]
)
AS_VAR_IF([[mhd_cv_macro_pagesize_usable]], [["yes"]],
[
AC_DEFINE([[MHD_USE_PAGESIZE_MACRO]],[[1]],[Define if you have usable PAGESIZE macro])
AC_CACHE_CHECK([whether PAGESIZE macro could be used for static init], [mhd_cv_macro_pagesize_usable_static],
[
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifndef PAGESIZE
#error No PAGESIZE macro defined
choke me now
#endif
static long ac_pgsz = PAGESIZE + 0;
]],
[[
if (1 > ac_pgsz) return 1;
]]
)
],
[[mhd_cv_macro_pagesize_usable_static="yes"]], [[mhd_cv_macro_pagesize_usable_static="no"]]
)
]
)
AS_VAR_IF([[mhd_cv_macro_pagesize_usable_static]], [["yes"]],
[AC_DEFINE([[MHD_USE_PAGESIZE_MACRO_STATIC]],[[1]],[Define if you have PAGESIZE macro usable for static init])]
)
],
[
AC_CACHE_CHECK([for usable PAGE_SIZE macro], [mhd_cv_macro_page_size_usable],
[
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifndef PAGE_SIZE
#error No PAGE_SIZE macro defined
choke me now
#endif
]],
[[
long pgsz = PAGE_SIZE + 0;
if (1 > pgsz) return 1;
]]
)
],
[[mhd_cv_macro_page_size_usable="yes"]], [[mhd_cv_macro_page_size_usable="no"]]
)
]
)
AS_VAR_IF([[mhd_cv_macro_page_size_usable]], [["yes"]],
[
AC_DEFINE([[MHD_USE_PAGE_SIZE_MACRO]],[[1]],[Define if you have usable PAGE_SIZE macro])
AC_CACHE_CHECK([whether PAGE_SIZE macro could be used for static init], [mhd_cv_macro_page_size_usable_static],
[
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifndef PAGE_SIZE
#error No PAGE_SIZE macro defined
choke me now
#endif
static long ac_pgsz = PAGE_SIZE + 0;
]],
[[
if (1 > ac_pgsz) return 1;
]]
)
],
[[mhd_cv_macro_page_size_usable_static="yes"]], [[mhd_cv_macro_page_size_usable_static="no"]]
)
]
)
AS_VAR_IF([[mhd_cv_macro_page_size_usable_static]], [["yes"]],
[AC_DEFINE([[MHD_USE_PAGE_SIZE_MACRO_STATIC]],[[1]],[Define if you have PAGE_SIZE macro usable for static init])]
)
]
)
]
)
# Check for inter-thread signaling type
AC_ARG_ENABLE([[itc]],
[AS_HELP_STRING([[--enable-itc=TYPE]], [use TYPE of inter-thread communication (pipe, socketpair, eventfd) [auto]])], [],
[[enable_itc='auto']]
)
AS_CASE([[$enable_itc]],
[[pipe]], [[:]],
[[socketpair]], [[:]],
[[eventfd]], [[:]],
[[auto]], [AS_VAR_IF([[os_is_windows]], [["yes"]], [[enable_itc='socketpair']])],
[[eventFD]], [[enable_itc='eventfd']],
[[socket]], [[enable_itc='socketpair']],
[[no]], [AC_MSG_ERROR([[inter-thread communication cannot be disabled]])],
[AC_MSG_ERROR([[unrecognized type "$enable_itc" of inter-thread communication specified by "--enable-itc=$enable_itc"]])]
)
AS_UNSET([[use_itc]])
AS_IF([[test "x$enable_itc" = "xeventfd" || test "x$enable_itc" = "xauto"]],
[
MHD_CHECK_LINK_RUN([[f][or working eventfd(2)]],[[mhd_cv_eventfd_usable]],[[mhd_cv_eventfd_usable='assuming no']],
[
AC_LANG_SOURCE([[
#include <sys/eventfd.h>
#include <unistd.h>
int main(void)
{
unsigned char buf[8];
int ret;
int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
if (0 > efd)
return 2;
ret = 0;
buf[3] = 1;
if (8 != write(efd, buf, 8))
ret = 3;
else
{
if (8 != read(efd, buf, 8))
ret = 4;
}
close(efd);
return ret;
}
]]
)
],
[
use_itc='eventfd'
enable_itc="$use_itc"
AC_DEFINE([[_MHD_ITC_EVENTFD]], [[1]], [Define to use eventFD for inter-thread communication])
],
[
AS_VAR_IF([[enable_itc]], [["eventfd"]], [AC_MSG_ERROR([[eventfd(2) is not usable, consider using other type of inter-thread communication]])])
]
)
AS_VAR_IF([mhd_cv_eventfd_usable],["assuming no"],
[AC_MSG_WARN([if you have 'eventfd' support enabled on your target system consider overriding test result by "mhd_cv_eventfd_usable=yes" configure parameter])]
)
]
)
AS_IF([[test "x$enable_itc" = "xpipe" || test "x$enable_itc" = "xauto"]], [
AS_VAR_IF([[os_is_native_w32]], [["yes"]], [], [
AC_CACHE_CHECK([[whether pipe(3) is usable]], [[mhd_cv_pipe_usable]], [
AC_LINK_IFELSE([
AC_LANG_PROGRAM([
AC_INCLUDES_DEFAULT
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
], [[
int arr[2];
int res;
res = pipe(arr);
if (res != 0) return 33;
close (arr[0]);
close (arr[1]);
]])
], [[mhd_cv_pipe_usable='yes']], [[mhd_cv_pipe_usable='no']])
])
AS_VAR_IF([[mhd_cv_pipe_usable]], [["yes"]], [
use_itc='pipe'
enable_itc="$use_itc"
AC_DEFINE([[_MHD_ITC_PIPE]], [[1]], [Define to use pipe for inter-thread communication])
MHD_CHECK_LINK_RUN([[whether pipe2(2) is usable]],[[mhd_cv_pipe2_usable]],
[
# Cross-compiling
AS_CASE([${host_os}], [kfreebsd*-gnu], [[mhd_cv_pipe2_usable='assuming no']],
[[mhd_cv_pipe2_usable='assuming yes']])
],
[
AC_LANG_PROGRAM([
AC_INCLUDES_DEFAULT
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
], [[
int arr[2];
int res;
res = pipe2(arr, O_CLOEXEC | O_NONBLOCK);
if (res != 0) return 33;
close (arr[0]);
close (arr[1]);
]]
)
],
[AC_DEFINE([[HAVE_PIPE2_FUNC]], [[1]], [Define if you have usable pipe2(2) function])]
)
], [
AS_VAR_IF([[enable_itc]], [["pipe"]], [AC_MSG_ERROR([[pipe(3) is not usable, consider using other type of inter-thread communication]])])
])
])
])
AS_IF([[test "x$enable_itc" = "xsocketpair" || test "x$enable_itc" = "xauto"]], [
AS_VAR_IF([[os_is_native_w32]], [["yes"]], [[mhd_cv_socketpair_usable='yes']], [
AC_CACHE_CHECK([[whether socketpair(3) is usable]], [[mhd_cv_socketpair_usable]], [
AC_LINK_IFELSE([
AC_LANG_PROGRAM([
AC_INCLUDES_DEFAULT
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
], [[
int arr[2];
int res;
#if defined(AF_LOCAL)
res = socketpair(AF_LOCAL, SOCK_STREAM, 0, arr);
#elif defined(AF_UNIX)
res = socketpair(AF_UNIX, SOCK_STREAM, 0, arr);
#else
#error AF_LOCAL and AF_UNIX are both undefined
choke me now;
#endif
if (res != 0) return 1
]])
], [[mhd_cv_socketpair_usable='yes']], [[mhd_cv_socketpair_usable='no']])
])
])
AS_VAR_IF([[mhd_cv_socketpair_usable]], [["yes"]], [
use_itc='socketpair'
enable_itc="$use_itc"
AC_DEFINE([[_MHD_ITC_SOCKETPAIR]], [[1]], [Define to use socketpair for inter-thread communication])
], [
AS_VAR_IF([[enable_itc]], [["socketpair"]], [AC_MSG_ERROR([[socketpair(3) is not usable, consider using other type of inter-thread communication]])])
])
])
AS_IF([[test -z "$use_itc"]], [AC_MSG_ERROR([[cannot find usable type of inter-thread communication]])])
MHD_CHECK_FUNC([accept4],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#include <sys/socket.h>
]],
[[
struct sockaddr sk_addr;
socklen_t addr_size;
i][f (0 > accept4(0, &sk_addr, &addr_size, 0))
return 3;
]]
)
MHD_CHECK_FUNC([gmtime_r],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#include <time.h>
]],
[[
time_t timer = (time_t) 0;
struct tm res;
i][f (&res != gmtime_r(&timer, &res))
return 3;
]]
)
MHD_CHECK_FUNC([memmem],
[[
#if defined(HAVE_STDDEF_H)
# include <stddef.h>
#elif defined(HAVE_STDLIB_H)
# include <stdlib.h>
#endif /* HAVE_STDLIB_H */
#include <string.h>
]],
[[
const char *haystack = "abc";
size_t hslen = 3;
const char *needle = "b";
size_t needlelen = 1;
i][f ((haystack + 1) != memmem(haystack, hslen, needle, needlelen))
return 3;
]]
)
MHD_CHECK_FUNC([snprintf],
[[
#include <stdio.h>
]],
[[
char buf[2];
i][f (1 != snprintf(buf, 2, "a"))
return 3;
/* Do not use the next check to avoid compiler warning */
/* i][f (4 != snprintf(buf, 2, "abcd"))
return 4; */
]]
)
AC_CHECK_DECL([gmtime_s],
[
AC_MSG_CHECKING([[whether gmtime_s is in C11 form]])
AC_LINK_IFELSE(
[ AC_LANG_PROGRAM(
[[
#define __STDC_WANT_LIB_EXT1__ 1
#include <time.h>
#ifdef __cplusplus
extern "C"
#endif
struct tm* gmtime_s(const time_t* time, struct tm* result);
]], [[
struct tm res;
time_t t;
gmtime_s (&t, &res);
]])
],
[
AC_DEFINE([HAVE_C11_GMTIME_S], [1], [Define to 1 if you have the `gmtime_s' function in C11 form.])
AC_MSG_RESULT([[yes]])
],
[
AC_MSG_RESULT([[no]])
AC_MSG_CHECKING([[whether gmtime_s is in W32 form]])
AC_LINK_IFELSE(
[ AC_LANG_PROGRAM(
[[
#include <time.h>
#ifdef __cplusplus
extern "C"
#endif
errno_t gmtime_s(struct tm* _tm, const time_t* time);
]], [[
struct tm res;
time_t t;
gmtime_s (&res, &t);
]])
],
[
AC_DEFINE([HAVE_W32_GMTIME_S], [1], [Define to 1 if you have the `gmtime_s' function in W32 form.])
AC_MSG_RESULT([[yes]])
],
[AC_MSG_RESULT([[no]])
])
])
], [],
[[#define __STDC_WANT_LIB_EXT1__ 1
#include <time.h>]])
AC_CHECK_DECL([SOCK_NONBLOCK], [AC_DEFINE([HAVE_SOCK_NONBLOCK], [1], [SOCK_NONBLOCK is defined in a socket header])], [],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#if defined(HAVE_SYS_SOCKET_H)
# include <sys/socket.h>
#elif defined(HAVE_WINSOCK2_H)
# include <winsock2.h>
#endif
]]
)
MHD_FIND_LIB([clock_gettime],[[#include <time.h>]],
[[
struct timespec tp;
i][f (0 > clock_gettime(CLOCK_REALTIME, &tp))
return 3;
]],
[rt],
[
AC_DEFINE([HAVE_CLOCK_GETTIME], [1], [Define to '1' if you have clock_gettime() function])
AS_VAR_IF([[mhd_cv_find_lib_clock_gettime]],[["none required"]], [],
[
MHD_LIBDEPS_PKGCFG="${mhd_cv_find_lib_clock_gettime} $MHD_LIBDEPS_PKGCFG"
]
)
],[],
[MHD_LIBDEPS]
)
MHD_CHECK_FUNC([clock_get_time],
[[
#include <mach/clock.h>
#include <mach/mach.h>
]],
[[
clock_serv_t cs;
mach_timespec_t mt;
host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cs);
clock_get_time(cs, &mt);
mach_port_deallocate(mach_task_self(), cs);
]]
)
MHD_CHECK_FUNC([gethrtime],
[[
#ifdef HAVE_SYS_TIME_H
/* Solaris define gethrtime() in sys/time.h */
#include <sys/time.h>
#endif /* HAVE_SYS_TIME_H */
#ifdef HAVE_TIME_H
/* HP-UX define gethrtime() in time.h */
#include <time.h>
#endif /* HAVE_TIME_H */
]],
[[
hrtime_t hrt = gethrtime();
i][f (0 == hrt)
return 3;
]]
)
AS_VAR_IF([ac_cv_header_time_h], ["yes"],
[
MHD_CHECK_FUNC([timespec_get],
[[
#include <time.h>
#ifndef TIME_UTC
#error TIME_UTC must be defined to use timespec_get()
choke me now
#endif
]],
[[
struct timespec ts;
i][f (TIME_UTC != timespec_get (&ts, TIME_UTC))
return 3;
]]
)
]
)
MHD_CHECK_FUNC_GETTIMEOFDAY
# IPv6
AC_CACHE_CHECK([for IPv6],[mhd_cv_have_inet6],
[
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <stdio.h>
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_WINSOCK2_H
#include <winsock2.h>
#endif
#ifdef HAVE_WS2TCPIP_H
#include <ws2tcpip.h>
#endif
]], [[
int af=AF_INET6;
int pf=PF_INET6;
struct sockaddr_in6 sa;
printf("%d %d %p\n", af, pf, (void*) &sa);
]]
)
],
[AS_VAR_SET([mhd_cv_have_inet6],["yes"])],
[AS_VAR_SET([mhd_cv_have_inet6],["no"])]
)
]
)
AS_VAR_IF([mhd_cv_have_inet6],["yes"],
[AC_DEFINE([HAVE_INET6], [1], [Define to '1' if you have IPv6 headers])]
)
MHD_CHECK_FUNC([[sysconf]], [[#include <unistd.h>]], [[long a = sysconf(0); if (a) return 1;]])
MHD_CHECK_FUNC([[sysctl]], [[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif
]], [[int mib[2] = {CTL_KERN, KERN_MAXPROC}; i][f (sysctl(mib, 2, NULL, NULL, NULL, 0)) return 1;]]
)
MHD_CHECK_FUNC([[sysctlbyname]], [[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
#ifdef HAVE_STDDEF_H
#include <stddef.h>
#endif
]], [[sysctlbyname("test", NULL, NULL, NULL, 0);]]
)
MHD_CHECK_FUNC([[usleep]], [[#include <unistd.h>]], [[usleep(100000);]])
MHD_CHECK_FUNC([[nanosleep]], [[#include <time.h>]], [[struct timespec ts2, ts1 = {0, 0}; nanosleep(&ts1, &ts2);]])
HIDDEN_VISIBILITY_CFLAGS=""
AH_TEMPLATE([_MHD_EXTERN],[defines how to decorate public symbols w][hile building the library])
CFLAGS="${user_CFLAGS}"
MHD_CHECK_CC_CFLAG([-fvisibility=hidden],[CFLAGS_ac],
[
# NOTE: require setting of errattr_CFLAGS above
CFLAGS="${CFLAGS_ac} -fvisibility=hidden ${user_CFLAGS} ${errattr_CFLAGS}"
AC_CACHE_CHECK([whether $CC supports __attribute__((visibility("default")))],[mhd_cv_cc_attr_visibility],
[
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
extern __attribute__((visibility("default"))) int test_extrn_func(void);
int test_extrn_func(void) {return 0;}
]])
],
[mhd_cv_cc_attr_visibility="yes"],[mhd_cv_cc_attr_visibility="no"]
)
]
)
AS_VAR_IF([mhd_cv_cc_attr_visibility],["yes"],
[
HIDDEN_VISIBILITY_CFLAGS="-fvisibility=hidden"
AS_IF([test "x$os_is_native_w32" = "xyes" && test "x$enable_shared" = "xyes"],
[AC_DEFINE([_MHD_EXTERN], [__attribute__((visibility("default"))) __declspec(dllexport) extern])],
[AC_DEFINE([_MHD_EXTERN], [__attribute__((visibility("default"))) extern])]
)
],
[
AC_MSG_WARN([$CC supports -fvisibility, but does not support __attribute__((visibility("default"))). Check compiler and compiler flags.])
AC_DEFINE([_MHD_EXTERN], [extern])
]
)
],[AC_DEFINE([_MHD_EXTERN], [extern])]
)
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
AC_SUBST([HIDDEN_VISIBILITY_CFLAGS])
# libcurl (required for testing)
AC_ARG_ENABLE([curl],
[AS_HELP_STRING([--disable-curl],[disable cURL based testcases])],
[enable_curl=${enableval}])
curl=0
AS_IF([test "$enable_curl" != "no"],
[LIBCURL_CHECK_CONFIG([yes],[7.16.4],[enable_curl=yes],
[
AS_IF([test "x$enable_curl" = "xyes"],
[AC_MSG_WARN([[cURL-based tests cannot be enabled because libcurl is missing]])])
enable_curl=no
])
])
AM_CONDITIONAL([RUN_LIBCURL_TESTS], [test "x$enable_curl" = "xyes"])
AS_IF([test "x$enable_curl" = "xyes"],
[MSG_CURL="yes"],
[MSG_CURL="no, many unit tests will not run"]
)
MHD_CHECK_FUNC([magic_open],
[[
#include <magic.h>
]],
[[
char var_data[256];
const char *var_mime;
magic_t var_magic = magic_open (MAGIC_MIME_TYPE);
(void)magic_load (var_magic, NULL);
var_data[0] = 0;
var_mime = magic_buffer (var_magic, var_data, 1);
magic_close (var_magic);
]],
[AC_DEFINE([MHD_HAVE_LIBMAGIC], [1], [Define to 1 if you have suitable libmagic.])],
[],
[-lmagic]
)
AM_CONDITIONAL([MHD_HAVE_LIBMAGIC], [[test "x$mhd_cv_func_magic_open" = "xyes"]])
# large file support (> 4 GB)
AC_SYS_LARGEFILE
AC_FUNC_FSEEKO
MHD_CHECK_FUNC([lseek64],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#include <unistd.h>
]],
[[
i][f (((off64_t) -1) == lseek64(0, (off64_t) 0, SEEK_SET))
return 3;
]]
)
MHD_CHECK_FUNC([pread64],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#include <unistd.h>
]],
[[
char buf[5];
i][f (0 > pread64(0, (void *) buf, 1, (off64_t) 0))
return 3;
]]
)
MHD_CHECK_FUNC([pread],
[[
#if defined(HAVE_SYS_TYPES_H)
# include <sys/types.h>
#endif
#include <unistd.h>
]],
[[
char buf[5];
i][f (0 > pread(0, (void *) buf, 1, 0))
return 3;
]]
)
# check for various sendfile functions
AC_ARG_ENABLE([sendfile],
[AS_HELP_STRING([--disable-sendfile],
[disable usage of sendfile() for HTTP connections [auto]])],
[],
[enable_sendfile="auto"])
AS_CASE([$enable_sendfile],
[[auto | yes]],[[found_sendfile="no"]],
[[no]],[[found_sendfile="disabled"]],
[AC_MSG_ERROR([[unknown value specified: --enable-sendfile=$enable_sendfile]])]
)
AS_VAR_IF([[found_sendfile]], [["no"]],
[
AC_MSG_CHECKING([[for Linux-style sendfile(2)]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#include <sys/sendfile.h>
static void empty_func(void)
{
/* Check for declaration */
(void)sendfile;
}
/* Declare again to check form match */
ssize_t sendfile(int, int, off_t*, size_t);
]],
[[
int fd1=0, fd2=2;
off_t o = 0;
size_t s = 5;
ssize_t r;
r = sendfile (fd1, fd2, &o, s);
if (r)
empty_func();
]]
)
],
[
AC_DEFINE([HAVE_LINUX_SENDFILE], [1], [Define to 1 if you have linux-style sendfile(2).])
found_sendfile="yes, Linux-style"
AC_MSG_RESULT([[yes]])
MHD_CHECK_FUNC([sendfile64],
[[
#include <sys/sendfile.h>
]],
[[
off64_t f_offset = (off64_t) 0;
if (0 > sendfile64 (0, 1, &f_offset, 1))
return 3;
]]
)
],
[AC_MSG_RESULT([[no]])
]
)
]
)
AS_VAR_IF([[found_sendfile]], [["no"]],
[
AC_MSG_CHECKING([[for FreeBSD-style sendfile(2)]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
static void empty_func(void)
{
/* Check for declaration */
(void)sendfile;
}
/* Declare again to check form match */
int sendfile(int, int, off_t, size_t,
struct sf_hdtr*, off_t*, int);
]],
[[
int fd1=0, fd2=1;
off_t o = 0;
size_t s = 5;
off_t r1;
int r2;
r2 = sendfile (fd1, fd2, o, s, (void*)0, &r1, 0);
if (r2)
empty_func();
]]
)
],
[
AC_DEFINE([HAVE_FREEBSD_SENDFILE], [1], [Define to 1 if you have FreeBSD-style sendfile(2).])
found_sendfile="yes, FreeBSD-style"
AC_MSG_RESULT([[yes]])
],
[AC_MSG_RESULT([[no]])
]
)
]
)
AS_VAR_IF([[found_sendfile]], [["no"]],
[
AC_MSG_CHECKING([[for Darwin-style sendfile(2)]])
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
static void empty_func(void)
{
/* Check for declaration */
(void)sendfile;
}
/* Declare again to check form match */
int sendfile(int, int, off_t, off_t*,
struct sf_hdtr *, int);
]],
[[
int fd=0, s=1;
off_t o = 0;
off_t l = 5;
int r;
r = sendfile (fd, s, o, &l, (void*)0, 0);
if (r)
empty_func();
]]
)
],
[
AC_DEFINE([HAVE_DARWIN_SENDFILE], [1], [Define to 1 if you have Darwin-style sendfile(2).])
found_sendfile="yes, Darwin-style"
AC_MSG_RESULT([[yes]])
],
[AC_MSG_RESULT([[no]])
]
)
]
)
AS_VAR_IF([[found_sendfile]], [["no"]],
[
AC_MSG_CHECKING([[for Solaris-style sendfile(3)]])
SAVE_LIBS="$LIBS"
LIBS="-lsendfile $LIBS"
AC_LINK_IFELSE(
[AC_LANG_PROGRAM(
[[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sendfile.h>
static void empty_func(void)
{
/* Check for declaration */
(void)sendfile;
}
/* Declare again to check form match */
ssize_t sendfile(int out_fd, int in_fd,
off_t *off, size_t len);
]],
[[
int fd1=0, fd2=1;
off_t o = 0;
size_t l = 5;
ssize_t r;
r = sendfile (fd1, fd2, &o, l);
if (r)
empty_func();
]]
)
],
[
AC_DEFINE([HAVE_SOLARIS_SENDFILE], [1], [Define to 1 if you have Solaris-style sendfile(3).])
found_sendfile="yes, Solaris-style"
MHD_LIBDEPS="-lsendfile $MHD_LIBDEPS"
MHD_LIBDEPS_PKGCFG="-lsendfile $MHD_LIBDEPS_PKGCFG"
AC_MSG_RESULT([[yes]])
MHD_CHECK_FUNC([sendfile64],
[[
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sendfile.h>
]],
[[
off64_t f_offset = (off64_t) 0;
if (0 > sendfile64 (0, 1, &f_offset, 1))
return 3;
]]
)
],
[AC_MSG_RESULT([[no]])
]
)
LIBS="$SAVE_LIBS"
]
)
AS_IF([[test "x$found_sendfile" = "xno" && test "x$enable_sendfile" = "xyes"]],
[AC_MSG_ERROR([[sendfile() usage was requested by configure parameter, but no usable sendfile() function is detected]])]
)
# optional: have error messages ?
AC_MSG_CHECKING([[whether to generate error messages]])
AC_ARG_ENABLE([messages],
[AS_HELP_STRING([--disable-messages],
[disable MHD error messages])],
[enable_messages=${enableval}],
[enable_messages=yes])
AS_IF([[test "x$enable_messages" = "xyes"]],
[ AC_DEFINE([HAVE_MESSAGES],[1],[Define to 1 to enable support for error messages.]) ],
[[ enable_messages=no ]])
AC_MSG_RESULT([[$enable_messages]])
# optional: have postprocessor?
AC_MSG_CHECKING([[whether to enable postprocessor]])
AC_ARG_ENABLE([postprocessor],
[AS_HELP_STRING([--disable-postprocessor],
[disable MHD PostProcessor functionality])],
[enable_postprocessor=${enableval}],
[enable_postprocessor=yes])
AS_IF([[test "x$enable_postprocessor" != "xno"]],
[ enable_postprocessor=yes
AC_DEFINE([HAVE_POSTPROCESSOR],[1],[Define to 1 if libmicrohttpd is compiled with postprocessor support.]) ])
AM_CONDITIONAL([HAVE_POSTPROCESSOR], [test "x$enable_postprocessor" != "xno"])
AC_MSG_RESULT([[$enable_postprocessor]])
# optional: have zzuf, socat?
run_zzuf_tests="no"
AS_VAR_IF([use_heavy_tests],["yes"],
[
AS_VAR_IF([enable_curl],["yes"],
[
AC_CHECK_PROG([have_zzuf],[zzuf],[yes],[no])
AS_VAR_IF([have_zzuf],["yes"],
[
AC_CHECK_PROG([have_socat],[socat],[yes],[no])
AS_VAR_IF([have_socat],["yes"],
[
run_zzuf_tests="yes"
run_zzuf_tests_MSG="yes"
],
[
run_zzuf_tests="no"
run_zzuf_tests_MSG="no, socat tool not found"
]
)
],
[
run_zzuf_tests="no"
run_zzuf_tests_MSG="no, zzuf tool not found"
]
)
],
[
run_zzuf_tests="no"
run_zzuf_tests_MSG="no, tests with libcurl are not enabled"
]
)
],
[
run_zzuf_tests="no"
run_zzuf_tests_MSG="no, heavy tests are not enabled"
]
)
AM_CONDITIONAL([RUN_ZZUF_TESTS],[test "x$run_zzuf_tests" = "xyes"])
have_gnutls=no
have_gnutls_sni=no
have_gcrypt=no
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
# optional: HTTPS support. Enabled by default
AC_ARG_ENABLE([https],
[AS_HELP_STRING([--enable-https],
[enable HTTPS support (yes, no, auto)[auto]])],
[enable_https=${enableval}])
AS_IF([test "x$enable_https" != "xno"],[
#
# Next block is large unindented block
#
# gnutls
have_gnutls_pkgcfg=no
AC_MSG_CHECKING([[how to find GnuTLS library]])
AC_ARG_WITH([[gnutls]],
[AS_HELP_STRING([[--with-gnutls[=PFX]]],[use GnuTLS for HTTPS support, optional PFX overrides pkg-config data for GnuTLS headers (PFX/include) and libs (PFX/lib)])],
[
AS_CASE([$with_gnutls],
[no],[
AC_MSG_RESULT([[GnuTLS disabled]])
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_CFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
AS_UNSET([GNUTLS_LIBS])
],
[yes],[
AC_MSG_RESULT([[automatically, forced]])
],
[
AC_MSG_RESULT([[-I$with_gnutls/include -L$with_gnutls/lib -lgnutls]])
SAVE_LIBS="$LIBS"
LDFLAGS="${LDFLAGS_ac} -L$with_gnutls/lib ${user_LDFLAGS}"
CPPFLAGS="${CPPFLAGS_ac} -I$with_gnutls/include ${user_CPPFLAGS}"
have_gnutls_pkgcfg=no
MHD_CHECK_FUNC([gnutls_check_version],[[#include <gnutls/gnutls.h>]],
[
if(!gnutls_check_version("2.0.0"))
return 3;
],
[
GNUTLS_CPPFLAGS="-I$with_gnutls/include"
GNUTLS_LDFLAGS="-L$with_gnutls/lib"
GNUTLS_LIBS="-lgnutls"
have_gnutls=yes
],
[AC_MSG_ERROR([can't find usable libgnutls at specified prefix $with_gnutls])],
[-lgnutls]
)
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
LIBS="$SAVE_LIBS"
])
],
[AC_MSG_RESULT([[automatically]])
])
AS_IF([test "x$with_gnutls" != "xno" && test "x$have_gnutls" != "xyes"],
[
AC_CACHE_CHECK([[whether to add pkg-config special search directories]], [mhd_cv_pkgconf_add_dirs],
[
AS_IF([[test "x$host_os" = "xsolaris2.11" && test "x$cross_compiling" = "xno"]],
[
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
char size_chk[7-sizeof(char*)];
#if defined(_LP64) || defined(__LP64__) || defined(__x86_64) || defined(__x86_64__)
#error This is 64-bit target.
choke me now
#endif
#if defined(__amd64) || defined(__amd64__) || defined(__sparcv9) || defined(__sparc_v9__)
#error This is 64-bit target.
choke me now
#endif
]], [[]]
)
],
[
mhd_cv_pkgconf_add_dirs='/usr/lib/pkgconfig/gnutls-3'
],
[
AS_IF([[test "x$host_cpu" = "xx86_64" || test "x$host_cpu" = "xi386"]],
[[mhd_cv_pkgconf_add_dirs='/usr/lib/amd64/pkgconfig/gnutls-3:/usr/lib/amd64/pkgconfig']],
[[test "x$host_cpu" = "xsparc"]],
[[mhd_cv_pkgconf_add_dirs='/usr/lib/sparkv9/pkgconfig/gnutls-3:/usr/lib/sparkv9/pkgconfig']],
[[mhd_cv_pkgconf_add_dirs='/usr/lib/64/pkgconfig/gnutls-3:/usr/lib/64/pkgconfig']]
)
]
)
],
[[ mhd_cv_pkgconf_add_dirs='no' ]]
)
]
)
AS_IF([[test "x$mhd_cv_pkgconf_add_dirs" != "xno"]],
[
test "x$PKG_CONFIG_PATH" = "x" || PKG_CONFIG_PATH="${PKG_CONFIG_PATH}${PATH_SEPARATOR}"
PKG_CONFIG_PATH="${PKG_CONFIG_PATH}${mhd_cv_pkgconf_add_dirs}"
export PKG_CONFIG_PATH
]
)
PKG_CHECK_MODULES(GNUTLS, [[gnutls]],
[
have_gnutls_pkgcfg='yes'
SAVE_LIBS="$LIBS"
CFLAGS="${CFLAGS_ac} $GNUTLS_CFLAGS ${user_CFLAGS}"
LIBS="$GNUTLS_LIBS $LIBS"
AC_MSG_CHECKING([[whether GnuTLS is usable]])
AC_LINK_IFELSE([
AC_LANG_PROGRAM([[
#include <gnutls/gnutls.h>
]], [[
gnutls_session_t session;
gnutls_priority_t priorities;
gnutls_global_init();
gnutls_priority_init(&priorities, "NORMAL", NULL);
gnutls_init(&session, GNUTLS_SERVER);
gnutls_priority_set(session, priorities);
]])],
[
AC_MSG_RESULT([[yes]])
have_gnutls=yes
# GNUTLS_CFLAGS is actually CPPFLAGS
GNUTLS_CPPFLAGS="$GNUTLS_CFLAGS"
# GNUTLS_LDFLAGS is a combination of LDFLAGS and LIBS
GNUTLS_LDFLAGS="$GNUTLS_LIBS"
],
[
AC_MSG_RESULT([[no]])
have_gnutls=no
])
AS_IF([test "x$have_gnutls" != "xyes"],
[
AC_MSG_WARN([pkg-config reports that GnuTLS is present, but GnuTLS can't be used])
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_CFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
AS_UNSET([GNUTLS_LIBS])
]
)
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
LIBS="$SAVE_LIBS"
],
[
# check for GnuTLS at default paths
have_gnutls_pkgcfg='no'
AC_CHECK_HEADERS([gnutls/gnutls.h],
[AC_CHECK_LIB([gnutls], [gnutls_priority_set],
[
GNUTLS_LIBS="-lgnutls"
have_gnutls=yes
])], [], [AC_INCLUDES_DEFAULT])
])
])
have_gcrypt='unknown'
AS_IF([test "x$with_gnutls" != "xno" && test "x$have_gnutls" != "xyes"],
[
AM_PATH_LIBGCRYPT([1.2.2], [have_gcrypt=yes], [have_gcrypt=no])
AS_IF([[test "x$have_gcrypt" = "xyes"]],
[
SAVE_LIBS="$LIBS"
CFLAGS="${CFLAGS_ac} $LIBGCRYPT_CFLAGS ${user_CFLAGS}"
# LIBGCRYPT_CFLAGS can be actually a CPPFLAGS, so check them both
CPPFLAGS="${CPPFLAGS_ac} $LIBGCRYPT_CFLAGS ${user_CPPFLAGS}"
AC_CHECK_HEADERS([gcrypt.h], [], [have_gcrypt=no], [AC_INCLUDES_DEFAULT])
# Check for GnuTLS with gcrypt flags
LDFLAGS="${LDFLAGS_ac} ${LIBGCRYPT_LIBS} ${user_LDFLAGS}"
# A bit of hack: unset cache variable to force recheck
AS_UNSET([ac_cv_header_gnutls_gnutls_h])
AC_CHECK_HEADERS([gnutls/gnutls.h],
[AS_UNSET([ac_cv_lib_gnutls_gnutls_priority_set]) # A bit of hack: unset cache variable to force recheck
AC_CHECK_LIB([gnutls], [gnutls_priority_set],
[
GNUTLS_CPPFLAGS="$LIBGCRYPT_CFLAGS"
GNUTLS_CFLAGS="$LIBGCRYPT_CFLAGS"
GNUTLS_LDFLAGS="$LIBGCRYPT_LIBS"
GNUTLS_LIBS="-lgnutls"
have_gnutls=yes
])], [], [AC_INCLUDES_DEFAULT])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
LIBS="$SAVE_LIBS"
]
)
]
)
AS_IF([test "x$have_gnutls" != "xyes" && test "x$with_gnutls" = "xyes"],
[AC_MSG_ERROR([[can't find usable libgnutls]])])
AS_IF([test "x$have_gnutls" = "xyes"],
[
SAVE_LIBS="$LIBS"
CPPFLAGS="${CPPFLAGS_ac} ${GNUTLS_CPPFLAGS} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${GNUTLS_CFLAGS} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${GNUTLS_LDFLAGS} ${user_LDFLAGS}"
LIBS="$GNUTLS_LIBS $LIBS"
AC_MSG_CHECKING([[for gnutls_privkey_import_x509_raw()]])
AC_LINK_IFELSE([
AC_LANG_PROGRAM([[
#include <gnutls/gnutls.h>
#include <gnutls/abstract.h>
]], [[
gnutls_datum_t data;
gnutls_privkey_t key = 0;
#ifndef gnutls_load_file
(void)gnutls_load_file; /* Check for declaration. */
#endif
#ifndef gnutls_privkey_import_x509_raw
(void)gnutls_privkey_import_x509_raw; /* Check for declaration. */
#endif
gnutls_load_file("key.pem", &data);
gnutls_privkey_import_x509_raw(key, &data, GNUTLS_X509_FMT_PEM, NULL, 0);
gnutls_free(data.data);
]])], [[have_gnutls_sni=yes]], [[have_gnutls_sni=no]])
AC_MSG_RESULT([[$have_gnutls_sni]])
AC_CACHE_CHECK([[whether GnuTLS require libgcrypt initialisation]], [mhd_cv_gcrypt_required],
[
AC_COMPILE_IFELSE(
[
AC_LANG_PROGRAM(
[
#include <gnutls/gnutls.h>
],
[
#if !defined(GNUTLS_VERSION_NUMBER) || GNUTLS_VERSION_NUMBER+0 <= 0x020c14
#error Old versions of GnuTLS require libgcript initialisation
choke me now
#endif
]
)
],
[[mhd_cv_gcrypt_required='no']], [[mhd_cv_gcrypt_required='yes']]
)
]
)
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
LIBS="$SAVE_LIBS"
],
[
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
]
)
AS_IF([[test "x$mhd_cv_gcrypt_required" = "xyes" && test "x$have_gcrypt" = "xunknown"]],
[
AM_PATH_LIBGCRYPT([1.2.2], [have_gcrypt=yes], [have_gcrypt=no])
AS_IF([[test "x$have_gcrypt" = "xyes"]],
[
CFLAGS="${CFLAGS_ac} ${LIBGCRYPT_CFLAGS} ${user_CFLAGS}"
# LIBGCRYPT_CFLAGS can be actually a CPPFLAGS, so check them both
CPPFLAGS="${CPPFLAGS_ac} ${LIBGCRYPT_CFLAGS} ${user_CPPFLAGS}"
AC_CHECK_HEADERS([gcrypt.h], [], [have_gcrypt=no], [AC_INCLUDES_DEFAULT])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
]
)
AS_UNSET([[crypt_missing]])
AS_IF([[test "x$have_gnutls" = "xyes"]],
[
AS_IF([[test "x$mhd_cv_gcrypt_required" = "xyes" && test "x$have_gcrypt" != "xyes"]],
[
crypt_missing="required libgcrypt"
AS_IF([[test "x$enable_https" = "xyes" ]], [AC_MSG_ERROR([[HTTPS support cannot be enabled without $crypt_missing.]])])
enable_https=no
MSG_HTTPS="no (lacking $crypt_missing)"
AS_UNSET([LIBGCRYPT_CFLAGS])
AS_UNSET([LIBGCRYPT_LIBS])
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_CFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
AS_UNSET([GNUTLS_LIBS])
],
[
AC_DEFINE([[HTTPS_SUPPORT]],[[1]],[Define to 1 if libmicrohttpd is compiled with HTTPS support.])
enable_https=yes
AS_IF([[test "x$mhd_cv_gcrypt_required" = "xyes"]],
[
MSG_HTTPS="yes (using libgnutls and libgcrypt)"
MHD_TLS_LIB_CPPFLAGS="$LIBGCRYPT_CFLAGS $GNUTLS_CPPFLAGS"
MHD_TLS_LIB_CFLAGS="$LIBGCRYPT_CFLAGS $GNUTLS_CFLAGS"
MHD_TLS_LIB_LDFLAGS="$GNUTLS_LDFLAGS"
MHD_TLS_LIBDEPS="$GNUTLS_LIBS $LIBGCRYPT_LIBS"
AC_DEFINE([[MHD_HTTPS_REQUIRE_GCRYPT]], [[1]], [Define to `1' if HTTPS require initialisation of libgcrypt])
],
[
MSG_HTTPS="yes (using libgnutls)"
AS_UNSET([LIBGCRYPT_CFLAGS])
AS_UNSET([LIBGCRYPT_LIBS])
MHD_TLS_LIB_CPPFLAGS="$GNUTLS_CPPFLAGS"
MHD_TLS_LIB_CFLAGS="$GNUTLS_CFLAGS"
MHD_TLS_LIB_LDFLAGS="$GNUTLS_LDFLAGS"
MHD_TLS_LIBDEPS="$GNUTLS_LIBS"
]
)
AS_IF([[ test "x$have_gnutls_pkgcfg" = "xyes" ]],
[ # remove GnuTLS from private libs in .pc file as it defined in Requires.private
MHD_REQ_PRIVATE='gnutls'
AS_IF([[test "x$mhd_cv_gcrypt_required" = "xyes"]],
[[MHD_LIBDEPS_PKGCFG="$LIBGCRYPT_LIBS $MHD_LIBDEPS_PKGCFG"]]
)
],
[
MHD_REQ_PRIVATE=''
AS_IF([[test "x$mhd_cv_gcrypt_required" = "xyes"]],
[[MHD_LIBDEPS_PKGCFG="$LIBGCRYPT_LIBS $MHD_LIBDEPS_PKGCFG"]]
)
MHD_LIBDEPS_PKGCFG="$GNUTLS_LIBS $MHD_LIBDEPS_PKGCFG"
])
]
)
],
[
crypt_missing="libgnutls"
AS_IF([[test "x$enable_https" = "xyes" ]], [AC_MSG_ERROR([[HTTPS support cannot be enabled without $crypt_missing.]])])
enable_https=no
MSG_HTTPS="no (lacking $crypt_missing)"
AS_UNSET([LIBGCRYPT_CFLAGS])
AS_UNSET([LIBGCRYPT_LIBS])
AS_UNSET([GNUTLS_CPPFLAGS])
AS_UNSET([GNUTLS_CFLAGS])
AS_UNSET([GNUTLS_LDFLAGS])
AS_UNSET([GNUTLS_LIBS])
]
)
],[
MSG_HTTPS="no (disabled)"
])
#
# End of large unindented block
#
AC_MSG_CHECKING(whether to support HTTPS)
AC_MSG_RESULT([$MSG_HTTPS])
AM_CONDITIONAL([HAVE_GNUTLS], [[test "x$have_gnutls" = "xyes"]])
AM_CONDITIONAL([HAVE_GNUTLS_SNI], [[test "x$have_gnutls_sni" = "xyes"]])
AM_CONDITIONAL([ENABLE_HTTPS], [test "x$enable_https" = "xyes"])
AM_CONDITIONAL([HTTPS_REQUIRE_GCRYPT], [[test "x$enable_https" = "xyes" && test "x$mhd_cv_gcrypt_required" = "xyes"]])
AC_SUBST([GNUTLS_CPPFLAGS])
AC_SUBST([GNUTLS_CFLAGS])
AC_SUBST([GNUTLS_LDFLAGS])
AC_SUBST([GNUTLS_LIBS])
AS_VAR_IF([have_gnutls], ["yes"],
[
AC_CACHE_CHECK([for GnuTLS quirks], [mhd_cv_gnutls_mthread_broken],
[
mhd_cv_gnutls_mthread_broken="no"
AS_IF([test -r /etc/redhat-release],
[
AS_IF([$FGREP ' release 6.' /etc/redhat-release >/dev/null || $FGREP '(Santiago)' /etc/redhat-release >/dev/null],
[mhd_cv_gnutls_mthread_broken="found"],
)
]
)
AS_VAR_IF([mhd_cv_gnutls_mthread_broken], ["no"],
[
AS_IF([command -v rpm >/dev/null],
[
AS_IF([test "r`rpm -E '%{rhel}' 2>/dev/null`" = "r6"],
[mhd_cv_gnutls_mthread_broken="found"],
)
]
)
]
)
]
)
AC_CACHE_CHECK([for gnutls-cli binary], [mhd_cv_gnutls_cli],
[
mhd_cv_gnutls_cli="no"
AS_IF([command -v gnutls-cli >/dev/null 2>&1],
[AS_IF([AC_RUN_LOG([gnutls-cli --version >&2])], [mhd_cv_gnutls_cli="yes"])]
)
]
)
]
)
AM_CONDITIONAL([HAVE_GNUTLS_MTHREAD_BROKEN], [[test "x${mhd_cv_gnutls_mthread_broken}" = "xfound"]])
AM_CONDITIONAL([USE_UPGRADE_TLS_TESTS], [[test "x${mhd_cv_gnutls_mthread_broken}" = "xno" || test "x${mhd_cv_gnutls_cli}" = "xyes"]])
# optional: HTTP Basic Auth support. Enabled by default
AC_MSG_CHECKING([[whether to support HTTP Basic authentication]])
AC_ARG_ENABLE([bauth],
[AS_HELP_STRING([--disable-bauth],[disable HTTP Basic Authentication support])],
[enable_bauth=${enableval}],
[enable_bauth=yes])
AS_IF([[test "x$enable_bauth" != "xno"]],
[ enable_bauth=yes
AC_DEFINE([BAUTH_SUPPORT],[1],[Define to 1 if libmicrohttpd is compiled with Basic Auth support.]) ])
AM_CONDITIONAL([ENABLE_BAUTH], [test "x$enable_bauth" != "xno"])
AC_MSG_RESULT([[$enable_bauth]])
# optional: HTTP Digest Auth support. Enabled by default
AC_MSG_CHECKING([[whether to support HTTP Digest authentication]])
AC_ARG_ENABLE([dauth],
[AS_HELP_STRING([--disable-dauth], [disable HTTP Digest Authentication support])],
[enable_dauth="${enableval}"],
[enable_dauth="yes"])
AS_IF([[test "x$enable_dauth" != "xno"]],
[ enable_dauth=yes
AC_DEFINE([DAUTH_SUPPORT],[1],[Define to 1 if libmicrohttpd is compiled with Digest Auth support.]) ])
AM_CONDITIONAL([ENABLE_DAUTH], [test "x$enable_dauth" != "xno"])
AC_MSG_RESULT([[$enable_dauth]])
AM_CONDITIONAL([HAVE_ANYAUTH],[test "x$enable_bauth" != "xno" || test "x$enable_dauth" != "xno"])
# optional: HTTP "Upgrade" support. Enabled by default
AC_MSG_CHECKING([[whether to support HTTP "Upgrade"]])
AC_ARG_ENABLE([[httpupgrade]],
[AS_HELP_STRING([[--disable-httpupgrade]], [disable HTTP "Upgrade" support])],
[AS_VAR_IF([[enable_httpupgrade]],[["no"]],[],[[enable_httpupgrade='yes']])],
[[enable_httpupgrade='yes']])
AS_VAR_IF([[enable_httpupgrade]],[["yes"]],
[
AC_DEFINE([[UPGRADE_SUPPORT]],[[1]],[Define to 1 if libmicrohttpd is compiled with HTTP Upgrade support.]) ])
AM_CONDITIONAL([ENABLE_UPGRADE], [[test "x$enable_httpupgrade" = "xyes"]])
AC_MSG_RESULT([[$enable_httpupgrade]])
# optional: HTTP cookie parsing support. Enabled by default
AC_MSG_CHECKING([[whether to support HTTP cookie parsing]])
AC_ARG_ENABLE([[cookie]],
[AS_HELP_STRING([[--disable-cookie]], [disable HTTP cookie parsing support])],
[AS_VAR_IF([[enable_cookie]],[["no"]],[],[[enable_cookie='yes']])],
[[enable_cookie='yes']])
AS_VAR_IF([[enable_cookie]],[["yes"]],
[
AC_DEFINE([[COOKIE_SUPPORT]],[[1]],[Define to 1 if libmicrohttpd is compiled with HTTP cookie parsing support.]) ])
AM_CONDITIONAL([ENABLE_COOKIE], [[test "x$enable_cookie" = "xyes"]])
AC_MSG_RESULT([[$enable_cookie]])
# optional: MD5 support for Digest Auth. Enabled by default.
AC_ARG_ENABLE([[md5]],
[AS_HELP_STRING([[--enable-md5=TYPE]],
[enable TYPE of MD5 hashing code (yes, no, builtin, tlslib) [yes if dauth enabled]])],
[
AS_VAR_IF([enable_md5],["internal"],[enable_md5='builtin'])
AS_VAR_IF([enable_md5],["built-in"],[enable_md5='builtin'])
AS_VAR_IF([enable_dauth],["yes"],[],
[
AS_VAR_IF([enable_md5],["no"],[],
[
AC_MSG_WARN([The parameter --enable-md5=${enable_md5} is ignored as Digest Authentication is disabled])
enable_md5='no'
]
)
]
)
], [[enable_md5="${enable_dauth}"]]
)
AS_CASE([${enable_md5}],[yes|tlslib],
[
AS_IF([test "x${enable_compact_code}" != "xno" || test "x$enable_md5" = "xtlslib"],
[
AS_IF([test "x$enable_https" = "xyes"],
[
AC_CACHE_CHECK([whether GnuTLS supports MD5 hashing],[mhd_cv_gnutls_md5],
[
CFLAGS="${CFLAGS_ac} ${GNUTLS_CFLAGS} ${user_CFLAGS}"
CPPFLAGS="${CPPFLAGS_ac} ${MHD_TLS_LIB_CPPFLAGS} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${MHD_TLS_LIB_CFLAGS} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${MHD_TLS_LIB_LDFLAGS} ${user_LDFLAGS}"
save_LIBS="$LIBS"
LIBS="${MHD_TLS_LIBDEPS} ${LIBS}"
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#include <gnutls/crypto.h>
]],
[[
gnutls_hash_hd_t hash_handle;
unsigned char digest[16];
int exit_code;
if (0 == gnutls_hash_init(&hash_handle, GNUTLS_DIG_MD5))
{
if (0 == gnutls_hash(hash_handle, "", 1))
{
gnutls_hash_output(hash_handle, digest);
if (0x93 == digest[0])
exit_code = 0;
else
exit_code = 7;
}
else
exit_code = 5;
gnutls_hash_deinit(hash_handle, (void *)0);
}
else
exit_code = 2;
if (exit_code)
return exit_code;
]]
)
],
[mhd_cv_gnutls_md5='yes'],[mhd_cv_gnutls_md5='no']
)
LIBS="${save_LIBS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
AS_VAR_IF([mhd_cv_gnutls_md5],["no"],
[
AS_VAR_IF([enable_md5],["tlslib"],
[AC_MSG_FAILURE([TLS library MD5 implementation is not available])]
)
enable_md5="builtin"
],
[enable_md5="tlslib"]
)
],
[
AS_VAR_IF([enable_md5],["tlslib"],
[AC_MSG_ERROR([HTTPS is not enabled, TLS library MD5 implementation cannot be used])]
)
enable_md5="builtin"
]
)
],
[
enable_md5="builtin"
]
)
]
)
AC_MSG_CHECKING([[whether to support MD5]])
AS_UNSET([enable_md5_MSG])
AS_CASE([${enable_md5}],
[builtin],[enable_md5_MSG='yes, built-in'],
[tlslib],[enable_md5_MSG='yes, external (TLS library)'],
[no],[enable_md5_MSG='no'],
[yes],[AC_MSG_ERROR([configure internal error: unexpected variable value])],
[AC_MSG_ERROR([Unrecognized parameter --enable-md5=${enable_md5}])]
)
AS_IF([test "x${enable_md5}" = "xbuiltin" || test "x${enable_md5}" = "xtlslib" ],
[
AC_DEFINE([[MHD_MD5_SUPPORT]],[[1]],
[Define to 1 if libmicrohttpd is compiled with MD5 hashing support.])
]
)
AS_IF([test "x${enable_md5}" = "xtlslib" ],
[
AC_DEFINE([[MHD_MD5_TLSLIB]],[[1]],
[Define to 1 if libmicrohttpd is compiled with MD5 hashing by TLS library.])
]
)
AM_CONDITIONAL([ENABLE_MD5], [[test "x${enable_md5}" = "xbuiltin" || test "x${enable_md5}" = "xtlslib" ]])
AM_CONDITIONAL([ENABLE_MD5_EXT], [[test "x${enable_md5}" = "xtlslib" ]])
AC_MSG_RESULT([[${enable_md5_MSG}]])
# optional: SHA-256 support for Digest Auth. Enabled by default.
AC_ARG_ENABLE([[sha256]],
[AS_HELP_STRING([[--enable-sha256=TYPE]],
[enable TYPE of SHA-256 hashing code (yes, no, builtin, tlslib) [yes if dauth enabled]])],
[
AS_VAR_IF([enable_sha256],["internal"],[enable_sha256='builtin'])
AS_VAR_IF([enable_sha256],["built-in"],[enable_sha256='builtin'])
AS_VAR_IF([enable_dauth],["yes"],[],
[
AS_VAR_IF([enable_sha256],["no"],[],
[
AC_MSG_WARN([The parameter --enable-sha256=${enable_sha256} is ignored as Digest Authentication is disabled])
enable_sha256='no'
]
)
]
)
], [[enable_sha256="${enable_dauth}"]]
)
AS_CASE([${enable_sha256}],[yes|tlslib],
[
AS_IF([test "x${enable_compact_code}" != "xno" || test "x$enable_sha256" = "xtlslib"],
[
AS_IF([test "x$enable_https" = "xyes"],
[
AC_CACHE_CHECK([whether GnuTLS supports sha256 hashing],[mhd_cv_gnutls_sha256],
[
CFLAGS="${CFLAGS_ac} ${GNUTLS_CFLAGS} ${user_CFLAGS}"
CPPFLAGS="${CPPFLAGS_ac} ${MHD_TLS_LIB_CPPFLAGS} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${MHD_TLS_LIB_CFLAGS} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${MHD_TLS_LIB_LDFLAGS} ${user_LDFLAGS}"
save_LIBS="$LIBS"
LIBS="${MHD_TLS_LIBDEPS} ${LIBS}"
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#include <gnutls/crypto.h>
]],
[[
gnutls_hash_hd_t hash_handle;
unsigned char digest[32];
int exit_code;
if (0 == gnutls_hash_init(&hash_handle, GNUTLS_DIG_SHA256))
{
if (0 == gnutls_hash(hash_handle, "", 1))
{
gnutls_hash_output(hash_handle, digest);
if (0x6e == digest[0])
exit_code = 0;
else
exit_code = 7;
}
else
exit_code = 5;
gnutls_hash_deinit(hash_handle, (void *)0);
}
else
exit_code = 2;
if (exit_code)
return exit_code;
]]
)
],
[mhd_cv_gnutls_sha256='yes'],[mhd_cv_gnutls_sha256='no']
)
LIBS="${save_LIBS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
LDFLAGS="${LDFLAGS_ac} ${user_LDFLAGS}"
]
)
AS_VAR_IF([mhd_cv_gnutls_sha256],["no"],
[
AS_VAR_IF([enable_sha256],["tlslib"],
[AC_MSG_FAILURE([TLS library SHA-256 implementation is not available])]
)
enable_sha256="builtin"
],
[enable_sha256="tlslib"]
)
],
[
AS_VAR_IF([enable_sha256],["tlslib"],
[AC_MSG_ERROR([HTTPS is not enabled, TLS library SHA-256 implementation cannot be used])]
)
enable_sha256="builtin"
]
)
],
[
enable_sha256="builtin"
]
)
]
)
AC_MSG_CHECKING([[whether to support SHA-256]])
AS_UNSET([enable_sha256_MSG])
AS_CASE([${enable_sha256}],
[builtin],[enable_sha256_MSG='yes, built-in'],
[tlslib],[enable_sha256_MSG='yes, external (TLS library)'],
[no],[enable_sha256_MSG='no'],
[yes],[AC_MSG_ERROR([configure internal error: unexpected variable value])],
[AC_MSG_ERROR([Unrecognized parameter --enable-sha256=${enable_sha256}])]
)
AS_IF([test "x${enable_sha256}" = "xbuiltin" || test "x${enable_sha256}" = "xtlslib" ],
[
AC_DEFINE([[MHD_SHA256_SUPPORT]],[[1]],
[Define to 1 if libmicrohttpd is compiled with SHA-256 hashing support.])
]
)
AS_IF([test "x${enable_sha256}" = "xtlslib" ],
[
AC_DEFINE([[MHD_SHA256_TLSLIB]],[[1]],
[Define to 1 if libmicrohttpd is compiled with SHA-256 hashing by TLS library.])
]
)
AM_CONDITIONAL([ENABLE_SHA256], [[test "x${enable_sha256}" = "xbuiltin" || test "x${enable_sha256}" = "xtlslib" ]])
AM_CONDITIONAL([ENABLE_SHA256_EXT], [[test "x${enable_sha256}" = "xtlslib" ]])
AC_MSG_RESULT([[${enable_sha256_MSG}]])
# optional: SHA-512/256 support for Digest Auth. Enabled by default.
AC_ARG_ENABLE([[sha512-256]],
[AS_HELP_STRING([[--disable-sha512-256]],
[disable SHA-512/256 hashing support for Digest Authentication])],
[
AS_VAR_IF([[enable_sha512_256]],[["yes"]],
[
AS_VAR_IF([enable_dauth],["yes"],[],
[
AC_MSG_WARN([The parameter --enable-sha512-256 is ignored as Digest Authentication is disabled])
enable_sha512_256='no'
]
)
],[[enable_sha512_256='no']]
)
], [[enable_sha512_256="${enable_dauth}"]]
)
AC_MSG_CHECKING([[whether to support SHA-512/256]])
AS_UNSET([enable_sha512_256_MSG])
AS_CASE([${enable_sha512_256}],
[yes],[enable_sha512_256_MSG='yes, built-in'],
[no],[enable_sha512_256_MSG='no'],
[AC_MSG_ERROR([Unrecognized parameter --enable-sha512-256=${enable_sha512_256}])]
)
AS_VAR_IF([[enable_sha512_256]],[["yes"]],
[
AC_DEFINE([[MHD_SHA512_256_SUPPORT]],[[1]],
[Define to 1 if libmicrohttpd is compiled with SHA-512/256 hashing support.])
]
)
AM_CONDITIONAL([ENABLE_SHA512_256], [[test "x${enable_sha512_256}" = "xyes"]])
AC_MSG_RESULT([[${enable_sha512_256_MSG}]])
AS_IF([test "x$enable_dauth" != "xno"],
[
AS_IF([test "x${enable_md5}" = "xno" && test "x${enable_sha256}" = "xno" && test "x${enable_sha512_256}" != "xyes"],
[AC_MSG_ERROR([At least one hashing algorithm must be enabled if Digest Auth is enabled])]
)
]
)
AC_CACHE_CHECK([[for calloc()]], [[mhd_cv_have_func_calloc]],
[
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <stdlib.h>
]],[[void * ptr = calloc(1, 2); if (ptr) return 1;]])
],
[[mhd_cv_have_func_calloc='yes']],
[[mhd_cv_have_func_calloc='no']]
)
]
)
AS_VAR_IF([[mhd_cv_have_func_calloc]], [["yes"]],
[AC_DEFINE([[HAVE_CALLOC]], [[1]], [Define to 1 if you have the usable `calloc' function.])])
# Some systems have IPv6 disabled in kernel at run-time
AS_IF([[test "x${mhd_cv_have_inet6}" = "xyes" && test "x${cross_compiling}" = "xno"]],
[
AC_CACHE_CHECK([whether IPv6 could be used for testing],[mhd_cv_ipv6_for_testing],
[
AC_RUN_IFELSE(
[
AC_LANG_SOURCE([[
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_WINSOCK2_H
#include <winsock2.h>
#endif
#ifdef HAVE_WS2TCPIP_H
#include <ws2tcpip.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_NETINET_IP_H
#include <netinet/ip.h>
#endif
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#ifdef HAVE_NETINET_TCP_H
#include <netinet/tcp.h>
#endif
static void zr_mem(void *ptr, socklen_t size)
{ char *mem = ptr; while(size--) {mem[0] = 0; mem++;} }
int main(void)
{
int ret = 30;
struct sockaddr_in6 sa;
#if !defined(_WIN32) || defined(__CYGWIN__)
int sckt;
const int invld_sckt = -1;
#else
SOCKET sckt;
const SOCKET invld_sckt = INVALID_SOCKET;
WSADATA wsa_data;
WSAStartup(MAKEWORD(2, 2), &wsa_data);
#endif
zr_mem(&sa, sizeof(sa));
sa.sin6_family = AF_INET6;
sa.sin6_port = 0;
sa.sin6_addr = in6addr_loopback;
#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
sa.sin6_len = sizeof(sa);
#endif
sckt = socket (PF_INET6, SOCK_STREAM, 0);
if (invld_sckt != sckt)
{
if (0 == bind (sckt, (struct sockaddr *)&sa, sizeof(sa)))
{
if (0 == listen (sckt, 1))
ret = 0;
else
ret = 1; /* listen() failed */
} else ret = 2; /* bind() failed */
#if !defined(_WIN32) || defined(__CYGWIN__)
close (sckt);
#else
closesocket (sckt);
#endif
} else ret = 3; /* socket() failed */
#if defined(_WIN32) && !defined(__CYGWIN__)
WSACleanup();
#endif
return ret;
}
]])
], [[mhd_cv_ipv6_for_testing="yes"]], [[mhd_cv_ipv6_for_testing="no"]], [[mhd_cv_ipv6_for_testing="no"]]
)
]
)
]
)
AS_VAR_IF([mhd_cv_ipv6_for_testing],["yes"],
[AC_DEFINE([[USE_IPV6_TESTING]], [[1]], [Define to 1 if your kernel supports IPv6 and IPv6 is enabled and useful for testing.])]
)
# Check for fork() and waitpid(). They are used for tests.
AC_MSG_CHECKING([[for fork()]])
mhd_have_fork_waitpid='no'
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
]], [[
pid_t p = fork ();
if (0 == p)
return 1;
]])
], [
AC_DEFINE([[HAVE_FORK]], [[1]], [Define to 1 if you have the usable `fork' function.])
AC_MSG_RESULT([[yes]])
AC_MSG_CHECKING([[for waitpid()]])
AC_LINK_IFELSE(
[
AC_LANG_PROGRAM(
[[
#include <sys/wait.h>
]], [[
pid_t p = fork ();
if (0 == p)
return 1;
waitpid (p, (void*)0, 0)
]])
], [
AC_DEFINE([[HAVE_WAITPID]], [[1]], [Define to 1 if you have the usable `waitpid' function.])
AC_MSG_RESULT([[yes]])
mhd_have_fork_waitpid='yes'
],[
AC_MSG_RESULT([[no]])
])
],[
AC_MSG_RESULT([[no]])
])
AM_CONDITIONAL([HAVE_FORK_WAITPID], [test "x$mhd_have_fork_waitpid" = "xyes"])
# gcov compilation
AC_MSG_CHECKING(whether to compile with support for code coverage analysis)
AC_ARG_ENABLE([coverage],
AS_HELP_STRING([--enable-coverage],
[compile the library with code coverage support]),
[use_gcov=${enableval}],
[use_gcov=no])
AC_MSG_RESULT($use_gcov)
AM_CONDITIONAL([USE_COVERAGE], [test "x$use_gcov" = "xyes"])
AX_COUNT_CPUS
AC_MSG_CHECKING([for number of CPU cores to use in tests])
AS_VAR_IF([use_heavy_tests], ["yes"],
[
# Enable usage of many core if heavy tests are enabled
AS_IF([[test "$CPU_COUNT" -gt "32"]], [[CPU_COUNT="32"]])dnl Limit resource usage
],
[
# Limit usage to just a few cores if heavy tests are not enabled
AS_IF([[test "$CPU_COUNT" -gt "6"]], [[CPU_COUNT="6"]])
AS_IF([[test "$CPU_COUNT" -lt "2"]], [[CPU_COUNT="2"]])
]
)
AC_MSG_RESULT([$CPU_COUNT])
AC_ARG_ENABLE([[asserts]],
[AS_HELP_STRING([[--enable-asserts]],
[enable test build with debug asserts])],
[],
[enable_asserts='auto']
)
AS_UNSET([use_asserts_MSG])
AC_CACHE_CHECK([[whether NDEBUG macro is defined]], [mhd_cv_macro_ndebug_def],
[
AC_LINK_IFELSE(
[
AC_LANG_SOURCE([[
#ifndef NDEBUG
#error NDEBUG is NOT defined
chome me now
#endif
int main(void)
{
return 0;
}
]]
)
],
[[mhd_cv_macro_ndebug_def='yes']],
[[mhd_cv_macro_ndebug_def='no']]
)
]
)
AS_VAR_IF([enable_asserts],["yes"],
[
AS_VAR_IF([mhd_cv_macro_ndebug_def],["yes"],
[
AC_MSG_FAILURE([Parameter --enable-asserts is specified, but NDEBUG macro is defined as well])
]
)
use_asserts_MSG="yes, enabled by configure parameter"
]
)
AC_CACHE_CHECK([[whether _DEBUG macro is defined]], [mhd_cv_macro__debug_def],
[
AC_LINK_IFELSE(
[
AC_LANG_SOURCE([[
#ifndef _DEBUG
#error _DEBUG is NOT defined
chome me now
#endif
int main(void)
{
return 0;
}
]]
)
],
[[mhd_cv_macro__debug_def='yes']],
[[mhd_cv_macro__debug_def='no']]
)
]
)
AS_VAR_IF([enable_asserts],["no"],
[
AS_VAR_IF([mhd_cv_macro__debug_def],["yes"],
[
AC_MSG_FAILURE([Parameter --disable-asserts is specified, but _DEBUG macro is defined as well])
]
)
use_asserts_MSG="no, set by configure parameter"
]
)
AS_IF([test "x${mhd_cv_macro_ndebug_def}" = "xyes" && test "x${mhd_cv_macro__debug_def}" = "xyes"],
[AC_MSG_FAILURE([Both NDEBUG and _DEBUG macros are defined])]
)
AS_VAR_IF([enable_asserts],["auto"],
[
AS_VAR_IF([mhd_cv_macro_ndebug_def],["yes"],
[
enable_asserts="no"
use_asserts_MSG="no, set by NDEBUG preprocessor macro"
]
)
]
)
AS_VAR_IF([enable_asserts],["auto"],
[
AS_VAR_IF([mhd_cv_macro__debug_def],["yes"],
[
enable_asserts="yes"
use_asserts_MSG="yes, enabled by _DEBUG preprocessor macro"
]
)
]
)
AS_VAR_IF([enable_asserts],["auto"],
[
AC_CACHE_CHECK([[whether DEBUG macro is defined]], [mhd_cv_macro_debug_def],
[
AC_LINK_IFELSE(
[
AC_LANG_SOURCE([[
#ifndef DEBUG
#error DEBUG is NOT defined
chome me now
#endif
int main(void)
{
return 0;
}
]]
)
],
[[mhd_cv_macro_debug_def='yes']],
[[mhd_cv_macro_debug_def='no']]
)
]
)
AS_VAR_IF([mhd_cv_macro_debug_def],["yes"],
[
enable_asserts="yes"
use_asserts_MSG="yes, enabled by DEBUG preprocessor macro"
]
)
]
)
AC_MSG_CHECKING([[whether to enable debug asserts]])
AS_VAR_IF([enable_asserts],["auto"],
[
AS_CASE([${enable_build_type}],
[debug|debugger],
[
enable_asserts="yes"
use_asserts_MSG="yes, enabled by --enable-bulid-type=${enable_build_type}"
],
[
enable_asserts="no"
use_asserts_MSG="no"
]
)
]
)
AS_CASE([[$enable_asserts]], [[yes]], [[:]], [[no]], [[:]], [[enable_asserts='no']])
AC_MSG_RESULT([[${use_asserts_MSG=no}]])
AS_VAR_IF([[enable_asserts]], [["yes"]],
[
AS_VAR_IF([[mhd_cv_macro__debug_def]], [["yes"]], [:],
[
MHD_PREPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-D_DEBUG=1])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
]
)
AC_CACHE_CHECK([[whether system assert() is available]], [mhd_cv_sys_assert_avail],
[
AC_LINK_IFELSE(
[
AC_LANG_SOURCE([[
#include <assert.h>
static int pos_val(void) {return 5;}
static int neg_val(void) {return -5;}
int main(void)
{
int pos_var = pos_val(), neg_var = neg_val();
assert(neg_var > pos_var); /* Must trigger assert. */
return pos_var + neg_var;
}
]])
],
[[mhd_cv_sys_assert_avail='yes']],
[[mhd_cv_sys_assert_avail='no']]
)
]
)
AS_VAR_IF([[mhd_cv_sys_assert_avail]], [["no"]], [],
[AC_DEFINE([[HAVE_ASSERT]], [[1]], [Define if you have usable assert() and assert.h])])
],
[
AS_VAR_IF([[mhd_cv_macro_ndebug_def]], [["yes"]], [:],
[
MHD_PREPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-DNDEBUG=1])
CPPFLAGS="${CPPFLAGS_ac} ${user_CPPFLAGS}"
]
)
]
)
AS_UNSET([enabled_sanitizers])
TESTS_ENVIRONMENT_ac=""
AM_ASAN_OPTIONS=""
AM_UBSAN_OPTIONS=""
AM_LSAN_OPTIONS=""
AS_UNSET([ASAN_OPTIONS])
AS_UNSET([UBSAN_OPTIONS])
AS_UNSET([LSAN_OPTIONS])
AC_MSG_CHECKING([whether to enable run-time sanitizers])
AC_ARG_ENABLE([sanitizers],
[AS_HELP_STRING([[--enable-sanitizers[=address,undefined,leak,user-poison]]],
[enable run-time sanitizers, specify the list of types of sanitizers to enable, ]
[leave the list empty (or set to "auto") to enable all supported and available ]
[sanitizers, or specify "auto-fallback" to use sanitizers even without ]
[installed sanitizer run-time library])],
[], [AS_CASE([${enable_build_type}],[debug],
[enable_sanitizers='auto-optional'],[enable_sanitizers='no'])]
)
AS_IF([test "x${enable_sanitizers}" = "x"], [enable_sanitizers="auto"])
AS_VAR_IF([enable_sanitizers], ["yes"], [enable_sanitizers="auto"])
AS_VAR_IF([enable_sanitizers], ["autofallback"], [enable_sanitizers="auto-fallback"])
AS_VAR_IF([enable_sanitizers], ["autooptional"], [enable_sanitizers="auto-optional"])
AS_IF([test "x${enable_sanitizers}" = "xno"],
[
enable_sanitizers="no"
enable_san_address="no"
enable_san_undef="no"
enable_san_leak="no"
enable_san_upoison="no"
],
[test "x${enable_sanitizers}" = "xauto" || test "x${enable_sanitizers}" = "xauto-optional"],
[
AS_VAR_IF([enable_compiler_hardening],["yes"],
[
AS_VAR_IF([enable_sanitizers],["auto"],
[AC_MSG_ERROR([sanitizers cannot be enabled with compiler hardnening])],
[AC_MSG_WARN([sanitizers cannot be enabled with compiler hardnening])]
)
enable_sanitizers="no"
enable_san_address="no"
enable_san_undef="no"
enable_san_leak="no"
enable_san_upoison="no"
],
[
enable_san_address="auto"
enable_san_undef="auto"
enable_san_leak="auto"
enable_san_upoison="auto"
]
)
],
[test "x${enable_sanitizers}" = "xauto-fallback"],
[
enable_san_address="auto"
enable_san_undef="auto-fallback"
enable_san_leak="auto"
enable_san_upoison="auto"
],
[
AS_UNSET([san])
enable_san_address="no"
enable_san_undef="no"
enable_san_leak="no"
enable_san_upoison="no"
f][or san in `AS_ECHO([${enable_sanitizers}]) | tr ',' ' '`
do
AS_CASE([$san],
[address], [enable_san_address="yes"],
[undefined], [enable_san_undef="yes"],
[leak], [enable_san_leak="yes"],
[user-poison|user_poison], [enable_san_upoison="yes"],
[no|yes|auto|auto-fallback|autofallback], [AC_MSG_ERROR(["$san" cannot be used with other options for --enable-sanitizers=])],
[AC_MSG_ERROR([Unknown parameter "$san" for --enable-sanitizers=])]
)
done
AS_IF([test "x${enable_san_upoison}" = "xyes" && test "x${enable_san_address}" = "xno"],
[AC_MSG_ERROR([User memory poisoning cannot be used without address sanitizer])]
)
enable_sanitizers="selected"
]
)
AS_CASE([${enable_sanitizers}],
[selected], [AC_MSG_RESULT([selected])],
[auto], [AC_MSG_RESULT([yes, detect and use supported sanitizers])],
[auto-fallback], [AC_MSG_RESULT([yes, detect and use supported sanitizers even without run-time lib])],
[auto-optional], [AC_MSG_RESULT([yes, detect and use supported sanitizers if any])],
[AC_MSG_RESULT([no])]
)
AS_VAR_IF([enable_sanitizers], ["no"], [:],
[
AS_UNSET([san_FLAGS]) # the sanitizer flags to be added to both CFLAGS and LDFLAGS
AS_UNSET([san_CFLAGS]) # the sanitizer flags to be added to CFLAGS
AC_CACHE_CHECK([whether '-fsanitize=' works for $CC],
[mhd_cv_cc_sanitizer_works],
[
CFLAGS="${CFLAGS_ac} -fsanitize=wrongFeatureName ${user_CFLAGS}"
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_works=no], [mhd_cv_cc_sanitizer_works=yes])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_works], ["yes"],
[
AS_VAR_IF([enable_san_address], ["no"], [:],
[
AC_CACHE_CHECK([for address sanitizer], [mhd_cv_cc_sanitizer_address],
[
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} -fsanitize=address ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_address=yes], [mhd_cv_cc_sanitizer_address=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_address],["yes"],
[
AC_DEFINE([MHD_ASAN_ACTIVE], [1], [Define to '1' if you have address sanitizer enabled])
AX_APPEND_FLAG([-fsanitize=address], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }address"
AS_VAR_IF([enable_san_leak], ["no"], [:],
[
AC_CACHE_CHECK([whether leak detect is not rejected by address sanitizer], [mhd_cv_cc_sanitizer_address_leak],
[
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} ${user_CFLAGS}"
ASAN_OPTIONS="exitcode=88:detect_leaks=1:halt_on_error=1"
export ASAN_OPTIONS
AC_RUN_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_address_leak=yes], [mhd_cv_cc_sanitizer_address_leak=no],
[
# Cross-compiling with sanitizers?
mhd_cv_cc_sanitizer_address_leak='assuming no'
]
)
AS_UNSET([ASAN_OPTIONS])
]
)
]
)
AC_CACHE_CHECK([for pointer compare sanitizer], [mhd_cv_cc_sanitizer_pointer_compare],
[
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} -fsanitize=pointer-compare ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_pointer_compare=yes], [mhd_cv_cc_sanitizer_pointer_compare=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_pointer_compare],["yes"],
[
AX_APPEND_FLAG([-fsanitize=pointer-compare], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }pointer compare"
]
)
AC_CACHE_CHECK([for pointer subtract sanitizer], [mhd_cv_cc_sanitizer_pointer_subtract],
[
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} -fsanitize=pointer-subtract ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_pointer_subtract=yes], [mhd_cv_cc_sanitizer_pointer_subtract=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_pointer_subtract],["yes"],
[
AX_APPEND_FLAG([-fsanitize=pointer-subtract], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }pointer subtract"
]
)
AS_VAR_IF([enable_san_upoison], ["no"], [:],
[
AC_CHECK_HEADERS([sanitizer/asan_interface.h], [], [], [AC_INCLUDES_DEFAULT])
AS_VAR_IF([ac_cv_header_sanitizer_asan_interface_h],["yes"],
[
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} ${errattr_CFLAGS} ${user_CFLAGS}"
MHD_CHECK_FUNC([__asan_address_is_poisoned],[[#include <sanitizer/asan_interface.h>]],
[[int a_var=1; i][f(__asan_address_is_poisoned((void*) &a_var)) return 3;]]
)
MHD_CHECK_FUNC([__asan_region_is_poisoned],[[#include <sanitizer/asan_interface.h>]],
[[int a_var=1; i][f(((void*) 0) != __asan_region_is_poisoned((void*) &a_var, sizeof(a_var))) return 3;]]
)
AC_CACHE_CHECK([whether special function attribute is needed for user-poison], [mhd_cv_func_u_p_attribute_needed],
[
ASAN_OPTIONS="exitcode=88:detect_invalid_pointer_pairs=3:halt_on_error=1"
export ASAN_OPTIONS
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} ${errattr_CFLAGS} ${user_CFLAGS}"
AC_RUN_IFELSE(
[
AC_LANG_SOURCE(
[[
#include <stdint.h>
#include <stdlib.h>
#include <sanitizer/asan_interface.h>
static const size_t first_pos = 0;
static const size_t mid_pos = 64;
static const size_t last_pos = 128;
static const size_t zone_size = 16;
static const size_t buf_size = 128 + 16;
static int ptr_compare(void *ptr1, uint8_t *ptr2)
{
if ((((uintptr_t) (uint8_t *)ptr1) >= ((uintptr_t)ptr2)))
return ((char *) ptr1)[0] < ((char *) ptr2)[0];
return ((char *) ptr1)[0] > ((char *) ptr2)[0];
}
static int ptr_subtract(void *ptr1, uint8_t *ptr2)
{
return ((size_t)(((uintptr_t)(uint8_t*)ptr1) - ((uintptr_t)ptr2))) <= last_pos;
}
int main(int argc, char *argv[])
{
char *buf = (char*) malloc (buf_size);
char *a;
char *b;
int ret;
(void) argv;
if (NULL == buf)
return 10;
ASAN_POISON_MEMORY_REGION (buf + first_pos + zone_size, mid_pos - first_pos - zone_size);
ASAN_POISON_MEMORY_REGION (buf + mid_pos + zone_size, last_pos - mid_pos - zone_size);
if (0 < argc)
a = buf + last_pos;
else
a = buf + first_pos;
b = buf + mid_pos;
*a = '0';
*b = '9';
if (ptr_compare((void *)a, (uint8_t*) b))
{
if (ptr_subtract((void *)a, (uint8_t*) b))
ret = 0;
else
ret = 10;
}
else
ret = 5;
ASAN_UNPOISON_MEMORY_REGION (buf, buf_size);
free (buf);
return ret;
}
]]
)
],
[mhd_cv_func_u_p_attribute_needed="no"], [mhd_cv_func_u_p_attribute_needed="yes"],
[
# Cross-compiling with sanitizers??
mhd_cv_func_up_attribute_needed='assuming no'
]
)
AS_UNSET([ASAN_OPTIONS])
]
)
]
)
AS_VAR_IF([mhd_cv_func_u_p_attribute_needed],["yes"],[:],
[
AC_DEFINE([FUNC_PTRCOMPARE_CAST_WORKAROUND_WORKS],[1],[Define to '1' if cast to 'uintptr_t' works for safely processing user-poisoned pointer])
]
)
AS_IF([test "x${mhd_cv_func_u_p_attribute_needed}" = "xyes" && test "x${ac_cv_header_sanitizer_asan_interface_h}" = "xyes"],
[
AC_CACHE_CHECK([whether '__attribute__((no_sanitize("pointer-compare")))' and '__attribute__((no_sanitize("pointer-subtract")))' work],
[mhd_cv_func_attribute_nosanitize_ptr],
[
ASAN_OPTIONS="exitcode=88:detect_invalid_pointer_pairs=3:halt_on_error=1"
export ASAN_OPTIONS
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} ${errattr_CFLAGS} ${user_CFLAGS}"
AC_RUN_IFELSE(
[
AC_LANG_SOURCE(
[[
#include <stdint.h>
#include <stdlib.h>
#include <sanitizer/asan_interface.h>
static const size_t first_pos = 0;
static const size_t mid_pos = 64;
static const size_t last_pos = 128;
static const size_t zone_size = 16;
static const size_t buf_size = 128 + 16;
__attribute__((no_sanitize("pointer-compare")))
static int ptr_compare(void *ptr1, uint8_t *ptr2)
{
if ((((const uint8_t*)ptr1) >= ((const uint8_t*)ptr2)))
return ((char *) ptr1)[0] < ((char *) ptr2)[0];
return ((char *) ptr1)[0] > ((char *) ptr2)[0];
}
__attribute__((no_sanitize("pointer-subtract")))
static int ptr_subtract(void *ptr1, uint8_t *ptr2)
{
return ((size_t)(((const uint8_t*)ptr1) - \
((const uint8_t*)ptr2))) <= last_pos;
}
int main(int argc, char *argv[])
{
char *buf = (char*) malloc (buf_size);
char *a;
char *b;
int ret;
(void) argv;
if (NULL == buf)
return 10;
ASAN_POISON_MEMORY_REGION (buf + first_pos + zone_size, mid_pos - first_pos - zone_size);
ASAN_POISON_MEMORY_REGION (buf + mid_pos + zone_size, last_pos - mid_pos - zone_size);
if (0 < argc)
a = buf + last_pos;
else
a = buf + first_pos;
b = buf + mid_pos;
*a = '0';
*b = '9';
if (ptr_compare((void *)a, (uint8_t*) b))
{
if (ptr_subtract((void *)a, (uint8_t*) b))
ret = 0;
else
ret = 10;
}
else
ret = 5;
ASAN_UNPOISON_MEMORY_REGION (buf, buf_size);
free (buf);
return ret;
}
]]
)
],
[mhd_cv_func_attribute_nosanitize_ptr=yes], [mhd_cv_func_attribute_nosanitize_ptr=no],
[
# Cross-compiling with sanitizers??
mhd_cv_func_attribute_nosanitize_ptr='assuming no'
]
)
AS_UNSET([ASAN_OPTIONS])
]
)
AS_VAR_IF([mhd_cv_func_attribute_nosanitize_ptr], ["yes"],
[
AC_DEFINE([FUNC_ATTR_PTRCOMPARE_WORKS],[1],[Define to '1' if '__attribute__((no_sanitize("pointer-compare")))' works])
AC_DEFINE([FUNC_ATTR_PTRSUBTRACT_WORKS],[1],[Define to '1' if '__attribute__((no_sanitize("pointer-subtract")))' works])
],
[
AC_CACHE_CHECK([whether '__attribute__((no_sanitize("address")))' works for pointers compare], [mhd_cv_func_attribute_nosanitize_addr],
[
ASAN_OPTIONS="exitcode=88:detect_invalid_pointer_pairs=3:halt_on_error=1"
export ASAN_OPTIONS
CFLAGS="${CFLAGS_ac} ${san_CFLAGS} ${san_FLAGS} ${errattr_CFLAGS} ${user_CFLAGS}"
AC_RUN_IFELSE(
[
AC_LANG_SOURCE(
[[
#include <stdint.h>
#include <stdlib.h>
#include <sanitizer/asan_interface.h>
static const size_t first_pos = 0;
static const size_t mid_pos = 64;
static const size_t last_pos = 128;
static const size_t zone_size = 16;
static const size_t buf_size = 128 + 16;
__attribute__((no_sanitize("address")))
static int ptr_compare(void *ptr1, uint8_t *ptr2)
{
if ((((const uint8_t*)ptr1) >= ((const uint8_t*)ptr2)))
return ((char *) ptr1)[0] < ((char *) ptr2)[0];
return ((char *) ptr1)[0] > ((char *) ptr2)[0];
}
__attribute__((no_sanitize("address")))
static int ptr_subtract(void *ptr1, uint8_t *ptr2)
{
return ((size_t)(((const uint8_t*)ptr1) - \
((const uint8_t*)ptr2))) <= last_pos;
}
int main(int argc, char *argv[])
{
char *buf = (char*) malloc (buf_size);
char *a;
char *b;
int ret;
(void) argv;
if (NULL == buf)
return 10;
ASAN_POISON_MEMORY_REGION (buf + first_pos + zone_size, mid_pos - first_pos - zone_size);
ASAN_POISON_MEMORY_REGION (buf + mid_pos + zone_size, last_pos - mid_pos - zone_size);
if (0 < argc)
a = buf + last_pos;
else
a = buf + first_pos;
b = buf + mid_pos;
*a = '0';
*b = '9';
if (ptr_compare((void *)a, (uint8_t*) b))
{
if (ptr_subtract((void *)a, (uint8_t*) b))
ret = 0;
else
ret = 10;
}
else
ret = 5;
ASAN_UNPOISON_MEMORY_REGION (buf, buf_size);
free (buf);
return ret;
}
]]
)
],
[mhd_cv_func_attribute_nosanitize_addr=yes], [mhd_cv_func_attribute_nosanitize_addr=no],
[
# Cross-compiling with sanitizers??
mhd_cv_func_attribute_nosanitize_addr='assuming no'
]
)
AS_UNSET([ASAN_OPTIONS])
]
)
AS_VAR_IF([mhd_cv_func_attribute_nosanitize_addr], ["yes"],
[AC_DEFINE([FUNC_ATTR_NOSANITIZE_WORKS],[1],[Define to '1' if '__attribute__((no_sanitize("address")))' works for pointers compare])]
)
]
)
]
)
]
)
]
)
AS_IF([test "x${enable_san_address}" = "xyes" && test "x${mhd_cv_cc_sanitizer_address}" != "xyes"],
[AC_MSG_ERROR([Address sanitizer cannot be enabled])]
)
enable_san_address="${mhd_cv_cc_sanitizer_address}"
]
)
AS_VAR_IF([enable_san_undef], ["no"], [:],
[
dnl Ensure that '#' will be processed correctly
[
test_undf_prog='
#include <stdio.h>
static void func_out_b(char *arr)
{
arr[0] = 0;
arr[16] = 2;
}
static unsigned int int_deref(void *ptr)
{
return (*((unsigned int*)ptr)) + 2;
}
static int func1(void)
{
char chr[16];
func_out_b (chr);
return (int) (int_deref(chr + 1) + int_deref(chr + 2));
}
int main(void)
{
unsigned long ulvar;
signed char ch1;
ulvar = -1 * func1();
ch1 = ulvar * 6UL;
printf("%lu\n", ulvar + ch1);
return 0;
}
'
]
AC_CACHE_CHECK([for undefined behavior sanitizer], [mhd_cv_cc_sanitizer_undefined],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} -fsanitize=undefined ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_SOURCE([${test_undf_prog}])],
[mhd_cv_cc_sanitizer_undefined=yes], [mhd_cv_cc_sanitizer_undefined=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_undefined],["yes"],
[
AX_APPEND_FLAG([-fsanitize=undefined], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }undefined"
],
[
AS_CASE([${enable_san_undef}], [yes|auto-fallback],
[
AC_CACHE_CHECK([for undefined behavior sanitizer with '-fsanitize-undefined-trap-on-error'], [mhd_cv_cc_sanitizer_undefined_trap],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} -fsanitize=undefined -fsanitize-undefined-trap-on-error ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_SOURCE([${test_undf_prog}])],
[mhd_cv_cc_sanitizer_undefined_trap=yes], [mhd_cv_cc_sanitizer_undefined_trap=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_undefined_trap], ["yes"],
[
AX_APPEND_FLAG([-fsanitize=undefined], [san_FLAGS])
AX_APPEND_FLAG([-fsanitize-undefined-trap-on-error], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }undefined"
AC_MSG_WARN([Enabled sanitizer without run-time library, error reporting will be limited])
],
[
AS_IF([test -z "${enabled_sanitizers}"],
[
# Last resort
AC_CACHE_CHECK([for undefined behavior sanitizer with '-fsanitize-trap=all'], [mhd_cv_cc_sanitizer_undefined_trap_all],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} -fsanitize=undefined -fsanitize-trap=all ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_SOURCE([${test_undf_prog}])],
[mhd_cv_cc_sanitizer_undefined_trap_all=yes], [mhd_cv_cc_sanitizer_undefined_trap_all=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_undefined_trap_all],["yes"],
[
AX_APPEND_FLAG([-fsanitize=undefined], [san_FLAGS])
AX_APPEND_FLAG([-fsanitize-trap=all], [san_FLAGS])
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} -fsanitize=undefined -fsanitize-trap=all ${user_CFLAGS}"
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }undefined"
AC_MSG_WARN([Enabled sanitizer without run-time library, error reporting will be limited])
]
)
]
)
]
)
AS_CASE(["$enabled_sanitizers"], [*undefined],
[
AS_VAR_IF([mhd_cv_cc_sanitizer_undefined], ["yes"],[],
[
# A workaround for broken clang which is trying to use UBSan lib
# even when instructed to not use it
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} ${user_CFLAGS}"
AX_APPEND_LINK_FLAGS([-fsanitize-trap=implicit-conversion],
[san_FLAGS], [], [AC_LANG_SOURCE([${test_undf_prog}])])
]
)
]
)
]
)
]
)
AS_CASE(["$enabled_sanitizers"], [*undefined],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} ${user_CFLAGS}"
AX_APPEND_LINK_FLAGS([-fsanitize=bounds-strict -fsanitize=local-bounds -fsanitize=implicit-conversion -fsanitize=nullability-arg],
[san_CFLAGS], [], [AC_LANG_SOURCE([${test_undf_prog}])])
]
)
AS_UNSET([test_undf_prog])
AS_CASE(["$enabled_sanitizers"],
[*undefined], [enable_san_undef="yes"],
[
AS_VAR_IF([enable_san_undef], [yes], [AC_MSG_ERROR([Undefined behavior sanitizer cannot be enabled])])
enable_san_undef="no"
]
)
]
)
AS_VAR_IF([enable_san_leak], ["no"], [:],
[
AC_CACHE_CHECK([for leak sanitizer], [mhd_cv_cc_sanitizer_leak],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} -fsanitize=leak ${user_CFLAGS}"
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
[mhd_cv_cc_sanitizer_leak=yes], [mhd_cv_cc_sanitizer_leak=no])
]
)
AS_VAR_IF([mhd_cv_cc_sanitizer_leak],["yes"],
[
AX_APPEND_FLAG([-fsanitize=leak], [san_FLAGS])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }leak"
]
)
AS_IF([test "x${enable_san_leak}" = "xyes" && test "x${mhd_cv_cc_sanitizer_leak}" != "xyes"],
[AC_MSG_ERROR([User poison cannot be enabled])]
)
enable_san_leak="${mhd_cv_cc_sanitizer_leak}"
]
)
AS_IF([test -z "${enabled_sanitizers}"],
[
AS_VAR_IF([enable_sanitizers], ["auto-optional"],
[
san_FLAGS=""
san_CFLAGS=""
],
[
AC_MSG_ERROR([cannot find any sanitizer supported by $CC])
]
)
],
[
AS_VAR_IF([enable_san_upoison], ["no"], [:],
[
AC_MSG_CHECKING([whether to enable user memory poisoning])
AS_IF([test "x${mhd_cv_cc_sanitizer_address}" = "xyes" && test "x${ac_cv_header_sanitizer_asan_interface_h}" = "xyes" && \
(test "x${mhd_cv_func_u_p_attribute_needed}" != "xyes" || test "x${mhd_cv_func_attribute_nosanitize_ptr}" = "xyes" || \
test "x${mhd_cv_func_attribute_nosanitize_addr}" = "xyes")],
[
AC_DEFINE([MHD_ASAN_POISON_ACTIVE], [1], [Define to '1' if user memory poison is used])
enabled_sanitizers="${enabled_sanitizers}${enabled_sanitizers:+, }user-poison"
enable_san_upoison="yes"
AC_MSG_RESULT([yes])
],
[
AC_MSG_RESULT([no])
AS_VAR_IF([enable_san_upoison], ["yes"],
[AC_MSG_ERROR([User memory poisoning cannot be enabled])])
enable_san_upoison="no"
]
)
]
)
AS_VAR_IF([enable_san_address], ["yes"],
[
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} ${user_CFLAGS}"
AC_CHECK_DECL([_FORTIFY_SOURCE],
[MHD_APPEND_FLAG_TO_VAR([CPPFLAGS_ac],[-U_FORTIFY_SOURCE])],
[],[/* no includes */])
AX_APPEND_FLAG([-D_FORTIFY_SOURCE=0], [san_CFLAGS])
],
[
AS_CASE([$enable_sanitizers], [auto|auto-fallback],
[AC_MSG_WARN([$CC does not support address sanitizer])])
]
)
CFLAGS="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS} ${user_CFLAGS}"
# Always stop on sanitizer error
AX_APPEND_COMPILE_FLAGS([-fno-sanitize-recover=all], [san_CFLAGS])
# Get a better output for sanitizers error reporting
AX_APPEND_COMPILE_FLAGS([-fno-omit-frame-pointer -fno-optimize-sibling-calls],
[san_CFLAGS])
AS_VAR_IF([enable_san_address], ["yes"],
[
AM_ASAN_OPTIONS="exitcode=88:strict_string_checks=1:detect_stack_use_after_return=1"
AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:check_initialization_order=1:strict_init_order=1:redzone=64"
AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:max_free_fill_size=1024:detect_invalid_pointer_pairs=3"
AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:handle_ioctl=1:halt_on_error=1"
AS_VAR_IF([enable_san_upoison], ["yes"], [AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:allow_user_poisoning=1"])
AS_VAR_IF([enable_san_leak], ["yes"],
[AS_VAR_IF([mhd_cv_cc_sanitizer_address_leak], ["yes"],
[AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:detect_leaks=1"])
], [AM_ASAN_OPTIONS="${AM_ASAN_OPTIONS}:detect_leaks=0"]
)
]
)
AS_VAR_IF([enable_san_undef], [yes],
[AM_UBSAN_OPTIONS="exitcode=87:print_stacktrace=1:halt_on_error=1"])
AS_VAR_IF([enable_san_leak], ["yes"],
[AM_LSAN_OPTIONS="use_unaligned=1"]
)
TESTS_ENVIRONMENT_ac='\
ASAN_OPTIONS="$(AM_ASAN_OPTIONS)" ; export ASAN_OPTIONS ; \
UBSAN_OPTIONS="$(AM_UBSAN_OPTIONS)" ; export UBSAN_OPTIONS ; \
LSAN_OPTIONS="$(AM_LSAN_OPTIONS)" ; export LSAN_OPTIONS ;'
]
)
]
)
CFLAGS_ac="${CFLAGS_ac} ${san_FLAGS} ${san_CFLAGS}"
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
# Final flags that may interfere with autoconf detections
AS_CASE([${enable_build_type}],[debug|debugger],
[ # Debug build or build for walking with debugger
CFLAGS="${user_CFLAGS}"
MHD_CHECK_ADD_CC_CFLAGS([-Wextra-semi -Wextra-semi-stmt], [CFLAGS_ac])
CFLAGS="${CFLAGS_ac} ${user_CFLAGS}"
]
)
AM_CONDITIONAL([USE_SANITIZERS],
[test -n "$enabled_sanitizers" && test "x$mhd_cv_cc_sanitizer_works" = "xyes"])
AC_SUBST([AM_ASAN_OPTIONS])
AC_SUBST([AM_UBSAN_OPTIONS])
AC_SUBST([AM_LSAN_OPTIONS])
AC_SUBST([TESTS_ENVIRONMENT_ac])
MHD_LIB_LDFLAGS="$MHD_LIB_LDFLAGS"
AC_SUBST([CPU_COUNT])
AC_SUBST([HEAVY_TESTS_NOTPARALLEL])
AM_SUBST_NOTMAKE([HEAVY_TESTS_NOTPARALLEL])
AC_SUBST(MHD_LIB_CPPFLAGS)
AC_SUBST(MHD_LIB_CFLAGS)
AC_SUBST(MHD_LIB_LDFLAGS)
AC_SUBST(MHD_LIBDEPS)
AC_SUBST(MHD_TLS_LIB_CPPFLAGS)
AC_SUBST(MHD_TLS_LIB_CFLAGS)
AC_SUBST(MHD_TLS_LIB_LDFLAGS)
AC_SUBST(MHD_TLS_LIBDEPS)
# for pkg-config
AC_SUBST([MHD_REQ_PRIVATE])
AC_SUBST([MHD_LIBDEPS_PKGCFG])
# Restore flags as set by the user
CFLAGS="${user_CFLAGS}"
LDFLAGS="${user_LDFLAGS}"
CPPFLAGS="${user_CPPFLAGS}"
AC_SUBST([CFLAGS])
AC_SUBST([LDFLAGS])
AC_SUBST([CPPFLAGS])
AC_SUBST([LIBS])
# Configure-defined flags
AC_SUBST([CFLAGS_ac])
AC_SUBST([LDFLAGS_ac])
AC_SUBST([CPPFLAGS_ac])
# Used for 'po' directory staff
AC_SUBST([ac_configure_args])
AC_SUBST([EMPTY_VAR],[])
AC_SUBST([MHD_AUX_DIR])
AC_CONFIG_FILES([po/po-configure.ac])
AC_CONFIG_COMMANDS([po/Makefile.in],
[
echo "Skipping update of po/Makefile.in"
echo "Real update of po/Makefile.in for 'make dist' is peformed by po-config.status"
]
)
AC_CONFIG_COMMANDS([po-directories],
[
echo "Skipping po-directories command."
echo "Real po-directories command for 'make dist' is implemented in po-config.status"
]
)
# We define the paths here, because MinGW/GCC expands paths
# passed through the command line ("-DDIR=..."). This would
# lead to hard-coded paths ("C:\mingw\mingw\bin...") that do
# not contain the actual installation.
AC_DEFINE_DIR([MHD_PLUGIN_INSTALL_PREFIX], [libdir/libmicrohttpd], [tls plugins])
# should experimental code be compiled (code that may not yet compile)?
AC_MSG_CHECKING(whether to compile experimental code)
AC_ARG_ENABLE([experimental],
[AS_HELP_STRING([--enable-experimental], [enable compiling experimental code])],
[enable_experimental=${enableval}],
[enable_experimental=no])
AC_MSG_RESULT($enable_experimental)
AM_CONDITIONAL([HAVE_EXPERIMENTAL], [test "x$enable_experimental" = "xyes"])
AC_CONFIG_FILES([libmicrohttpd.pc
w32/common/microhttpd_dll_res_vc.rc
Makefile
contrib/Makefile
doc/Makefile
doc/doxygen/libmicrohttpd.doxy
doc/doxygen/Makefile
doc/examples/Makefile
m4/Makefile
src/Makefile
src/include/Makefile
src/lib/Makefile
src/microhttpd/Makefile
src/microhttpd_ws/Makefile
src/examples/Makefile
src/testcurl/Makefile
src/testcurl/https/Makefile
src/testzzuf/Makefile])
AC_OUTPUT
# Finally: summary
# Format flags without extra spaces for visual beauty
fin_CPPFLAGS="$user_CPPFLAGS"
fin_CFLAGS="$user_CFLAGS"
fin_LDFLAGS="$user_LDFLAGS"
MHD_PREPEND_FLAG_TO_VAR([fin_CPPFLAGS],[$CPPFLAGS_ac])
MHD_PREPEND_FLAG_TO_VAR([fin_CFLAGS],[$CFLAGS_ac])
MHD_PREPEND_FLAG_TO_VAR([fin_LDFLAGS],[$LDFLAGS_ac])
fin_lib_CPPFLAGS="$user_CPPFLAGS"
fin_lib_CFLAGS="$user_CFLAGS"
fin_lib_LDFLAGS="$user_LDFLAGS"
MHD_PREPEND_FLAG_TO_VAR([fin_lib_CPPFLAGS],[$MHD_LIB_CPPFLAGS])
MHD_PREPEND_FLAG_TO_VAR([fin_lib_CFLAGS],[$MHD_LIB_CFLAGS])
MHD_PREPEND_FLAG_TO_VAR([fin_lib_LDFLAGS],[$MHD_LIB_LDFLAGS])
MHD_PREPEND_FLAG_TO_VAR([fin_lib_CPPFLAGS],[$CPPFLAGS_ac])
MHD_PREPEND_FLAG_TO_VAR([fin_lib_CFLAGS],[$CFLAGS_ac])
MHD_PREPEND_FLAG_TO_VAR([fin_lib_LDFLAGS],[$LDFLAGS_ac])
AC_MSG_NOTICE([Toolchain settings:
CC=$CC
User/system/default flags:
CPPFLAGS="$user_CPPFLAGS"
CFLAGS= "$user_CFLAGS"
LDFLAGS= "$user_LDFLAGS"
Final set of the flags for tests and examples:
CPPFLAGS="$fin_CPPFLAGS"
CFLAGS= "$fin_CFLAGS"
LDFLAGS= "$fin_LDFLAGS"
Final set of the flags for ${PACKAGE_NAME} library:
CPPFLAGS="$fin_lib_CPPFLAGS"
CFLAGS= "$fin_lib_CFLAGS"
LDFLAGS= "$fin_lib_LDFLAGS"
])
AS_UNSET([fin_CPPFLAGS])
AS_UNSET([fin_CFLAGS])
AS_UNSET([fin_LDFLAGS])
AS_UNSET([fin_lib_CPPFLAGS])
AS_UNSET([fin_lib_CFLAGS])
AS_UNSET([fin_lib_LDFLAGS])
AS_VAR_IF([os_is_windows], ["yes"],
[os_ver_msg="
Target W32 ver: ${mhd_w32_ver_msg}"], [AS_UNSET([[os_ver_msg]])])
AC_MSG_NOTICE([GNU libmicrohttpd ${PACKAGE_VERSION} Configuration Summary:
Target directory: ${prefix}
Cross-compiling: ${cross_compiling}
Operating System: ${mhd_host_os}${os_ver_msg}
Messages: ${enable_messages}
Cookie parsing: ${enable_cookie}
Postproc: ${enable_postprocessor}
HTTP "Upgrade": ${enable_httpupgrade}
Basic auth.: ${enable_bauth}
Digest auth.: ${enable_dauth}
MD5: ${enable_md5_MSG}
SHA-256: ${enable_sha256_MSG}
SHA-512/256: ${enable_sha512_256_MSG}
Shutdown of listening socket triggers select: ${mhd_cv_host_shtdwn_trgr_select}
Inter-thread comm: ${use_itc}
Threading lib: ${USE_THREADS}
poll support: ${enable_poll=no}
epoll support: ${enable_epoll=no}
sendfile used: ${found_sendfile}
HTTPS support: ${MSG_HTTPS}
Compact code: ${enable_compact_code} (${compact_code_MSG})
Use thread names: ${enable_thread_names}
Use debug asserts: ${use_asserts_MSG=no}
Use sanitizers: ${enabled_sanitizers:=no}
Build docs: ${enable_doc}
Build examples: ${enable_examples}
Build static lib: ${enable_static}
Build shared lib: ${enable_shared}
Test with libcurl: ${MSG_CURL}
Heavy tests: ${use_heavy_tests_MSG}
Fuzzing tests: ${run_zzuf_tests_MSG=no}
])
AS_IF([test "x$enable_https" = "xyes"],
[AC_MSG_NOTICE([HTTPS subsystem configuration:
License : LGPL version 2.1 or any later version
])],
[AC_MSG_NOTICE([
License : LGPLv2.1+ or eCos
])])
AS_IF([test "x$enable_bauth" != "xyes" || \
test "x$enable_dauth" != "xyes" || \
test "x${enable_md5}" = "xno" || \
test "x${enable_sha256}" = "xno" || \
test "x${enable_sha512_256}" != "xyes" || \
test "x$enable_httpupgrade" != "xyes" || \
test "x$enable_cookie" != "xyes" || \
test "x$enable_postprocessor" != "xyes"],
[AC_MSG_NOTICE([WARNING: This will be a custom build with missing symbols. Do NOT use this build in a distribution. Building with these kinds of configure options is only for custom builds for embedded systems.])])
Reference in New Issue View Git Blame Copy Permalink