# Configure.ac script for Libgcrypt

# Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006,

#               2007, 2008, 2009, 2011 Free Software Foundation, Inc.

# Copyright (C) 2012-2017  g10 Code GmbH

#

# This file is part of Libgcrypt.

#

# Libgcrypt is free software; you can redistribute it and/or modify

# it under the terms of the GNU Lesser General Public License as

# published by the Free Software Foundation; either version 2.1 of

# the License, or (at your option) any later version.

#

# Libgcrypt 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 Lesser General Public License for more details.

#

# You should have received a copy of the GNU Lesser General Public

# License along with this program; if not, see <http://www.gnu.org/licenses/>.

# (Process this file with autoconf to produce a configure script.)

AC_REVISION($Revision$)

AC_PREREQ(2.60)

min_automake_version="1.14"

# To build a release you need to create a tag with the version number

# (git tag -s libgcrypt-n.m.k) and run "./autogen.sh --force".  Please

# bump the version number immediately after the release and do another

# commit and push so that the git magic is able to work.  See below

# for the LT versions.

m4_define(mym4_version_major, [1])

m4_define(mym4_version_minor, [8])

m4_define(mym4_version_micro, [5])

# Below is m4 magic to extract and compute the revision number, the

# decimalized short revision number, a beta version string, and a flag

# indicating a development version (mym4_isgit). Note that the m4

# processing is done by autoconf and not during the configure run.

m4_define(mym4_version,

          [mym4_version_major.mym4_version_minor.mym4_version_micro])

m4_define([mym4_revision],

          m4_esyscmd([git rev-parse --short HEAD | tr -d '\n\r']))

m4_define([mym4_revision_dec],

          m4_esyscmd_s([echo $((0x$(echo ]mym4_revision[|head -c 4)))]))

m4_define([mym4_betastring],

          m4_esyscmd_s([git describe --match 'libgcrypt-[0-9].*[0-9]' --long|\

                        awk -F- '$3!=0{print"-beta"$3}']))

m4_define([mym4_isgit],m4_if(mym4_betastring,[],[no],[yes]))

m4_define([mym4_full_version],[mym4_version[]mym4_betastring])

AC_INIT([libgcrypt],[mym4_full_version],[http://bugs.gnupg.org])

# LT Version numbers: In this branch we only change the revision.

#   (Interfaces removed:    CURRENT++, AGE=0, REVISION=0)

#   (Interfaces added:      CURRENT++, AGE++, REVISION=0)

#   (No interfaces changed:                   REVISION++)

LIBGCRYPT_LT_CURRENT=22

LIBGCRYPT_LT_AGE=2

LIBGCRYPT_LT_REVISION=5

# If the API is changed in an incompatible way: increment the next counter.

#

# 1.6: ABI and API change but the change is to most users irrelevant

#      and thus the API version number has not been incremented.

LIBGCRYPT_CONFIG_API_VERSION=1

# If you change the required gpg-error version, please remove

# unnecessary error code defines in src/gcrypt-int.h.

NEED_GPG_ERROR_VERSION=1.25

PACKAGE=$PACKAGE_NAME

VERSION=$PACKAGE_VERSION

AC_CONFIG_AUX_DIR([build-aux])

AC_CONFIG_SRCDIR([src/libgcrypt.vers])

AM_INIT_AUTOMAKE([serial-tests dist-bzip2])

AC_CONFIG_HEADER(config.h)

AC_CONFIG_MACRO_DIR([m4])

AC_CONFIG_LIBOBJ_DIR([compat])

AC_CANONICAL_HOST

AM_MAINTAINER_MODE

AM_SILENT_RULES

AC_ARG_VAR(SYSROOT,[locate config scripts also below that directory])

AH_TOP([

#ifndef _GCRYPT_CONFIG_H_INCLUDED

#define _GCRYPT_CONFIG_H_INCLUDED

/* Enable gpg-error's strerror macro for W32CE.  */

#define GPG_ERR_ENABLE_ERRNO_MACROS 1

])

AH_BOTTOM([

#define _GCRYPT_IN_LIBGCRYPT 1

/* If the configure check for endianness has been disabled, get it from

   OS macros.  This is intended for making fat binary builds on OS X.  */

#ifdef DISABLED_ENDIAN_CHECK

# if defined(__BIG_ENDIAN__)

#  define WORDS_BIGENDIAN 1

# elif defined(__LITTLE_ENDIAN__)

#  undef WORDS_BIGENDIAN

# else

#  error "No endianness found"

# endif

#endif /*DISABLED_ENDIAN_CHECK*/

/* We basically use the original Camellia source.  Make sure the symbols

   properly prefixed.  */

#define CAMELLIA_EXT_SYM_PREFIX _gcry_

#endif /*_GCRYPT_CONFIG_H_INCLUDED*/

])

AH_VERBATIM([_REENTRANT],

[/* To allow the use of Libgcrypt in multithreaded programs we have to use

    special features from the library. */

#ifndef _REENTRANT

# define _REENTRANT 1

#endif

])

AC_SUBST(LIBGCRYPT_LT_CURRENT)

AC_SUBST(LIBGCRYPT_LT_AGE)

AC_SUBST(LIBGCRYPT_LT_REVISION)

AC_SUBST(PACKAGE)

AC_SUBST(VERSION)

AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package])

AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version of this package])

VERSION_NUMBER=m4_esyscmd(printf "0x%02x%02x%02x" mym4_version_major \

                          mym4_version_minor mym4_version_micro)

AC_SUBST(VERSION_NUMBER)

######################

##  Basic checks.  ### (we need some results later on (e.g. $GCC)

######################

AC_PROG_MAKE_SET

missing_dir=`cd $ac_aux_dir && pwd`

AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)

AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)

AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)

AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)

# AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)

AC_PROG_CC

AC_PROG_CPP

AM_PROG_CC_C_O

AM_PROG_AS

AC_ISC_POSIX

AC_PROG_INSTALL

AC_PROG_AWK

AC_GNU_SOURCE

# We need to compile and run a program on the build machine.  A

# comment in libgpg-error says that the AC_PROG_CC_FOR_BUILD macro in

# the AC archive is broken for autoconf 2.57.  Given that there is no

# newer version of that macro, we assume that it is also broken for

# autoconf 2.61 and thus we use a simple but usually sufficient

# approach.

AC_MSG_CHECKING(for cc for build)

if test "$cross_compiling" = "yes"; then

  CC_FOR_BUILD="${CC_FOR_BUILD-cc}"

else

  CC_FOR_BUILD="${CC_FOR_BUILD-$CC}"

fi

AC_MSG_RESULT($CC_FOR_BUILD)

AC_ARG_VAR(CC_FOR_BUILD,[build system C compiler])

LT_PREREQ([2.2.6])

LT_INIT([win32-dll disable-static])

LT_LANG([Windows Resource])

##########################

## General definitions. ##

##########################

# Used by libgcrypt-config

LIBGCRYPT_CONFIG_LIBS="-lgcrypt"

LIBGCRYPT_CONFIG_CFLAGS=""

LIBGCRYPT_CONFIG_HOST="$host"

# Definitions for symmetric ciphers.

available_ciphers="arcfour blowfish cast5 des aes twofish serpent rfc2268 seed"

available_ciphers="$available_ciphers camellia idea salsa20 gost28147 chacha20"

enabled_ciphers=""

# Definitions for public-key ciphers.

available_pubkey_ciphers="dsa elgamal rsa ecc"

enabled_pubkey_ciphers=""

# Definitions for message digests.

available_digests="crc gostr3411-94 md2 md4 md5 rmd160 sha1 sha256 sha512"

available_digests="$available_digests sha3 tiger whirlpool stribog blake2"

enabled_digests=""

# Definitions for kdfs (optional ones)

available_kdfs="s2k pkdf2 scrypt"

enabled_kdfs=""

# Definitions for random modules.

available_random_modules="linux egd unix"

auto_random_modules="$available_random_modules"

# Supported thread backends.

LIBGCRYPT_THREAD_MODULES=""

# Other definitions.

have_w32_system=no

have_w32ce_system=no

have_pthread=no

# Setup some stuff depending on host.

case "${host}" in

    *-*-mingw32*)

      ac_cv_have_dev_random=no

      have_w32_system=yes

      case "${host}" in

        *-mingw32ce*)

            have_w32ce_system=yes

            available_random_modules="w32ce"

            ;;

        *)

            available_random_modules="w32"

            ;;

      esac

      AC_DEFINE(USE_ONLY_8DOT3,1,

                [set this to limit filenames to the 8.3 format])

      AC_DEFINE(HAVE_DRIVE_LETTERS,1,

                [defined if we must run on a stupid file system])

      AC_DEFINE(HAVE_DOSISH_SYSTEM,1,

                [defined if we run on some of the PCDOS like systems

                 (DOS, Windoze. OS/2) with special properties like

                  no file modes])

      ;;

    i?86-emx-os2 | i?86-*-os2*emx)

        # OS/2 with the EMX environment

        ac_cv_have_dev_random=no

        AC_DEFINE(HAVE_DRIVE_LETTERS)

        AC_DEFINE(HAVE_DOSISH_SYSTEM)

        ;;

    i?86-*-msdosdjgpp*)

        # DOS with the DJGPP environment

        ac_cv_have_dev_random=no

        AC_DEFINE(HAVE_DRIVE_LETTERS)

        AC_DEFINE(HAVE_DOSISH_SYSTEM)

        ;;

    *-*-hpux*)

        if test -z "$GCC" ; then

            CFLAGS="$CFLAGS -Ae -D_HPUX_SOURCE"

        fi

        ;;

    *-dec-osf4*)

        if test -z "$GCC" ; then

            # Suppress all warnings

            # to get rid of the unsigned/signed char mismatch warnings.

            CFLAGS="$CFLAGS -w"

        fi

        ;;

    m68k-atari-mint)

        ;;

    *-apple-darwin*)

        AC_DEFINE(_DARWIN_C_SOURCE, 900000L,

                  Expose all libc features (__DARWIN_C_FULL).)

        ;;

    *)

      ;;

esac

if test "$have_w32_system" = yes; then

   AC_DEFINE(HAVE_W32_SYSTEM,1, [Defined if we run on a W32 API based system])

   if test "$have_w32ce_system" = yes; then

     AC_DEFINE(HAVE_W32CE_SYSTEM,1,[Defined if we run on WindowsCE])

   fi

fi

AM_CONDITIONAL(HAVE_W32_SYSTEM, test "$have_w32_system" = yes)

AM_CONDITIONAL(HAVE_W32CE_SYSTEM, test "$have_w32ce_system" = yes)

# A printable OS Name is sometimes useful.

case "${host}" in

    *-*-mingw32ce*)

        PRINTABLE_OS_NAME="W32CE"

        ;;

    *-*-mingw32*)

        PRINTABLE_OS_NAME="W32"

        ;;

    i?86-emx-os2 | i?86-*-os2*emx )

        PRINTABLE_OS_NAME="OS/2"

        ;;

    i?86-*-msdosdjgpp*)

        PRINTABLE_OS_NAME="MSDOS/DJGPP"

        ;;

    *-linux*)

        PRINTABLE_OS_NAME="GNU/Linux"

        ;;

    *)

        PRINTABLE_OS_NAME=`uname -s || echo "Unknown"`

        ;;

esac

NAME_OF_DEV_RANDOM="/dev/random"

NAME_OF_DEV_URANDOM="/dev/urandom"

AC_ARG_ENABLE(endian-check,

              AC_HELP_STRING([--disable-endian-check],

	      [disable the endian check and trust the OS provided macros]),

	      endiancheck=$enableval,endiancheck=yes)

if test x"$endiancheck" = xyes ; then

  AC_C_BIGENDIAN

else

  AC_DEFINE(DISABLED_ENDIAN_CHECK,1,[configure did not test for endianness])

fi

AC_CHECK_SIZEOF(unsigned short, 2)

AC_CHECK_SIZEOF(unsigned int, 4)

AC_CHECK_SIZEOF(unsigned long, 4)

AC_CHECK_SIZEOF(unsigned long long, 0)

AC_CHECK_SIZEOF(void *, 0)

AC_TYPE_UINTPTR_T

if test "$ac_cv_sizeof_unsigned_short" = "0" \

   || test "$ac_cv_sizeof_unsigned_int" = "0" \

   || test "$ac_cv_sizeof_unsigned_long" = "0"; then

    AC_MSG_WARN([Hmmm, something is wrong with the sizes - using defaults]);

fi

# Ensure that we have UINT64_C before we bother to check for uint64_t

AC_CACHE_CHECK([for UINT64_C],[gnupg_cv_uint64_c_works],

   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <inttypes.h>]],

       [[uint64_t foo=UINT64_C(42);]])],

     gnupg_cv_uint64_c_works=yes,gnupg_cv_uint64_c_works=no))

if test "$gnupg_cv_uint64_c_works" = "yes" ; then

   AC_CHECK_SIZEOF(uint64_t)

fi

# Do we have any 64-bit data types?

if test "$ac_cv_sizeof_unsigned_int" != "8" \

   && test "$ac_cv_sizeof_unsigned_long" != "8" \

   && test "$ac_cv_sizeof_unsigned_long_long" != "8" \

   && test "$ac_cv_sizeof_uint64_t" != "8"; then

    AC_MSG_ERROR([[

***

*** No 64-bit integer type available.

*** It is not possible to build Libgcrypt on this platform.

***]])

fi

# If not specified otherwise, all available algorithms will be

# included.

default_ciphers="$available_ciphers"

default_pubkey_ciphers="$available_pubkey_ciphers"

default_digests="$available_digests"

default_kdfs="$available_kdfs"

# Blacklist MD2 by default

default_digests=`echo $default_digests | sed -e 's/md2//g'`

# Substitutions to set generated files in a Emacs buffer to read-only.

AC_SUBST(emacs_local_vars_begin, ['Local Variables:'])

AC_SUBST(emacs_local_vars_read_only, ['buffer-read-only: t'])

AC_SUBST(emacs_local_vars_end, ['End:'])

############################

## Command line switches. ##

############################

# Implementation of the --enable-ciphers switch.

AC_ARG_ENABLE(ciphers,

	      AC_HELP_STRING([--enable-ciphers=ciphers],

			     [select the symmetric ciphers to include]),

	      [enabled_ciphers=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],

	      [enabled_ciphers=""])

if test "x$enabled_ciphers" = "x" \

   -o "$enabled_ciphers" = "yes"  \

   -o "$enabled_ciphers" = "no"; then

   enabled_ciphers=$default_ciphers

fi

AC_MSG_CHECKING([which symmetric ciphers to include])

for cipher in $enabled_ciphers; do

    LIST_MEMBER($cipher, $available_ciphers)

    if test "$found" = "0"; then

       AC_MSG_ERROR([unsupported cipher "$cipher" specified])

    fi

done

AC_MSG_RESULT([$enabled_ciphers])

# Implementation of the --enable-pubkey-ciphers switch.

AC_ARG_ENABLE(pubkey-ciphers,

	      AC_HELP_STRING([--enable-pubkey-ciphers=ciphers],

			     [select the public-key ciphers to include]),

	      [enabled_pubkey_ciphers=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],

	      [enabled_pubkey_ciphers=""])

if test "x$enabled_pubkey_ciphers" = "x" \

   -o "$enabled_pubkey_ciphers" = "yes"  \

   -o "$enabled_pubkey_ciphers" = "no"; then

   enabled_pubkey_ciphers=$default_pubkey_ciphers

fi

AC_MSG_CHECKING([which public-key ciphers to include])

for cipher in $enabled_pubkey_ciphers; do

    LIST_MEMBER($cipher, $available_pubkey_ciphers)

    if test "$found" = "0"; then

       AC_MSG_ERROR([unsupported public-key cipher specified])

    fi

done

AC_MSG_RESULT([$enabled_pubkey_ciphers])

# Implementation of the --enable-digests switch.

AC_ARG_ENABLE(digests,

	      AC_HELP_STRING([--enable-digests=digests],

			     [select the message digests to include]),

	      [enabled_digests=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],

	      [enabled_digests=""])

if test "x$enabled_digests" = "x" \

   -o "$enabled_digests" = "yes"  \

   -o "$enabled_digests" = "no"; then

   enabled_digests=$default_digests

fi

AC_MSG_CHECKING([which message digests to include])

for digest in $enabled_digests; do

    LIST_MEMBER($digest, $available_digests)

    if test "$found" = "0"; then

       AC_MSG_ERROR([unsupported message digest specified])

    fi

done

AC_MSG_RESULT([$enabled_digests])

# Implementation of the --enable-kdfs switch.

AC_ARG_ENABLE(kdfs,

      AC_HELP_STRING([--enable-kfds=kdfs],

		     [select the KDFs to include]),

      [enabled_kdfs=`echo $enableval | tr ',:' '  ' | tr '[A-Z]' '[a-z]'`],

      [enabled_kdfs=""])

if test "x$enabled_kdfs" = "x" \

   -o "$enabled_kdfs" = "yes"  \

   -o "$enabled_kdfs" = "no"; then

   enabled_kdfs=$default_kdfs

fi

AC_MSG_CHECKING([which key derivation functions to include])

for kdf in $enabled_kdfs; do

    LIST_MEMBER($kdf, $available_kdfs)

    if test "$found" = "0"; then

       AC_MSG_ERROR([unsupported key derivation function specified])

    fi

done

AC_MSG_RESULT([$enabled_kdfs])

# Implementation of the --enable-random switch.

AC_ARG_ENABLE(random,

	      AC_HELP_STRING([--enable-random=name],

	                     [select which random number generator to use]),

	      [random=`echo $enableval | tr '[A-Z]' '[a-z]'`],

	      [])

if test "x$random" = "x" -o "$random" = "yes" -o "$random" = "no"; then

    random=default

fi

AC_MSG_CHECKING([which random module to use])

if test "$random" != "default" -a "$random" != "auto"; then

    LIST_MEMBER($random, $available_random_modules)

    if test "$found" = "0"; then

       AC_MSG_ERROR([unsupported random module specified])

    fi

fi

AC_MSG_RESULT($random)

# Implementation of the --disable-dev-random switch.

AC_MSG_CHECKING([whether use of /dev/random is requested])

AC_ARG_ENABLE(dev-random,

[  --disable-dev-random    disable the use of dev random],

    try_dev_random=$enableval, try_dev_random=yes)

AC_MSG_RESULT($try_dev_random)

# Implementation of the --with-egd-socket switch.

AC_ARG_WITH(egd-socket,

    [  --with-egd-socket=NAME  Use NAME for the EGD socket)],

            egd_socket_name="$withval", egd_socket_name="" )

AC_DEFINE_UNQUOTED(EGD_SOCKET_NAME, "$egd_socket_name",

                   [Define if you don't want the default EGD socket name.

                    For details see cipher/rndegd.c])

# Implementation of the --enable-random-daemon

AC_MSG_CHECKING([whether the experimental random daemon is requested])

AC_ARG_ENABLE([random-daemon],

              AC_HELP_STRING([--enable-random-daemon],

                             [Build and support the experimental gcryptrnd]),

              [use_random_daemon=$enableval],

              [use_random_daemon=no])

AC_MSG_RESULT($use_random_daemon)

if test x$use_random_daemon = xyes ; then

    AC_DEFINE(USE_RANDOM_DAEMON,1,

              [Define to support the experimental random daemon])

fi

AM_CONDITIONAL(USE_RANDOM_DAEMON, test x$use_random_daemon = xyes)

# Implementation of --disable-asm.

AC_MSG_CHECKING([whether MPI assembler modules are requested])

AC_ARG_ENABLE([asm],

              AC_HELP_STRING([--disable-asm],

	                     [Disable MPI assembler modules]),

              [try_asm_modules=$enableval],

              [try_asm_modules=yes])

AC_MSG_RESULT($try_asm_modules)

# Implementation of the --enable-m-guard switch.

AC_MSG_CHECKING([whether memory guard is requested])

AC_ARG_ENABLE(m-guard,

              AC_HELP_STRING([--enable-m-guard],

                             [Enable memory guard facility]),

              [use_m_guard=$enableval], [use_m_guard=no])

AC_MSG_RESULT($use_m_guard)

if test "$use_m_guard" = yes ; then

    AC_DEFINE(M_GUARD,1,[Define to use the (obsolete) malloc guarding feature])

fi

# Implementation of the --enable-large-data-tests switch.

AC_MSG_CHECKING([whether to run large data tests])

AC_ARG_ENABLE(large-data-tests,

              AC_HELP_STRING([--enable-large-data-tests],

                 [Enable the real long ruinning large data tests]),

	      large_data_tests=$enableval,large_data_tests=no)

AC_MSG_RESULT($large_data_tests)

AC_SUBST(RUN_LARGE_DATA_TESTS, $large_data_tests)

# Implementation of the --with-capabilities switch.

# Check whether we want to use Linux capabilities

AC_MSG_CHECKING([whether use of capabilities is requested])

AC_ARG_WITH(capabilities,

            AC_HELP_STRING([--with-capabilities],

                           [Use linux capabilities [default=no]]),

            [use_capabilities="$withval"],[use_capabilities=no])

AC_MSG_RESULT($use_capabilities)

# Implementation of the --enable-hmac-binary-check.

AC_MSG_CHECKING([whether a HMAC binary check is requested])

AC_ARG_ENABLE(hmac-binary-check,

              AC_HELP_STRING([--enable-hmac-binary-check],

                             [Enable library integrity check]),

              [use_hmac_binary_check=$enableval],

              [use_hmac_binary_check=no])

AC_MSG_RESULT($use_hmac_binary_check)

if test "$use_hmac_binary_check" = yes ; then

    AC_DEFINE(ENABLE_HMAC_BINARY_CHECK,1,

              [Define to support an HMAC based integrity check])

fi

# Implementation of the --disable-jent-support switch.

AC_MSG_CHECKING([whether jitter entropy support is requested])

AC_ARG_ENABLE(jent-support,

              AC_HELP_STRING([--disable-jent-support],

                        [Disable support for the Jitter entropy collector]),

	      jentsupport=$enableval,jentsupport=yes)

AC_MSG_RESULT($jentsupport)

# Implementation of the --disable-padlock-support switch.

AC_MSG_CHECKING([whether padlock support is requested])

AC_ARG_ENABLE(padlock-support,

              AC_HELP_STRING([--disable-padlock-support],

       	         [Disable support for the PadLock Engine of VIA processors]),

	      padlocksupport=$enableval,padlocksupport=yes)

AC_MSG_RESULT($padlocksupport)

# Implementation of the --disable-aesni-support switch.

AC_MSG_CHECKING([whether AESNI support is requested])

AC_ARG_ENABLE(aesni-support,

              AC_HELP_STRING([--disable-aesni-support],

                 [Disable support for the Intel AES-NI instructions]),

	      aesnisupport=$enableval,aesnisupport=yes)

AC_MSG_RESULT($aesnisupport)

# Implementation of the --disable-pclmul-support switch.

AC_MSG_CHECKING([whether PCLMUL support is requested])

AC_ARG_ENABLE(pclmul-support,

              AC_HELP_STRING([--disable-pclmul-support],

                 [Disable support for the Intel PCLMUL instructions]),

	      pclmulsupport=$enableval,pclmulsupport=yes)

AC_MSG_RESULT($pclmulsupport)

# Implementation of the --disable-sse41-support switch.

AC_MSG_CHECKING([whether SSE4.1 support is requested])

AC_ARG_ENABLE(sse41-support,

              AC_HELP_STRING([--disable-sse41-support],

                 [Disable support for the Intel SSE4.1 instructions]),

	      sse41support=$enableval,sse41support=yes)

AC_MSG_RESULT($sse41support)

# Implementation of the --disable-drng-support switch.

AC_MSG_CHECKING([whether DRNG support is requested])

AC_ARG_ENABLE(drng-support,

              AC_HELP_STRING([--disable-drng-support],

                 [Disable support for the Intel DRNG (RDRAND instruction)]),

	      drngsupport=$enableval,drngsupport=yes)

AC_MSG_RESULT($drngsupport)

# Implementation of the --disable-avx-support switch.

AC_MSG_CHECKING([whether AVX support is requested])

AC_ARG_ENABLE(avx-support,

              AC_HELP_STRING([--disable-avx-support],

                 [Disable support for the Intel AVX instructions]),

	      avxsupport=$enableval,avxsupport=yes)

AC_MSG_RESULT($avxsupport)

# Implementation of the --disable-avx2-support switch.

AC_MSG_CHECKING([whether AVX2 support is requested])

AC_ARG_ENABLE(avx2-support,

              AC_HELP_STRING([--disable-avx2-support],

                 [Disable support for the Intel AVX2 instructions]),

	      avx2support=$enableval,avx2support=yes)

AC_MSG_RESULT($avx2support)

# Implementation of the --disable-neon-support switch.

AC_MSG_CHECKING([whether NEON support is requested])

AC_ARG_ENABLE(neon-support,

              AC_HELP_STRING([--disable-neon-support],

                 [Disable support for the ARM NEON instructions]),

	      neonsupport=$enableval,neonsupport=yes)

AC_MSG_RESULT($neonsupport)

# Implementation of the --disable-arm-crypto-support switch.

AC_MSG_CHECKING([whether ARMv8 Crypto Extension support is requested])

AC_ARG_ENABLE(arm-crypto-support,

              AC_HELP_STRING([--disable-arm-crypto-support],

                 [Disable support for the ARMv8 Crypto Extension instructions]),

	      armcryptosupport=$enableval,armcryptosupport=yes)

AC_MSG_RESULT($armcryptosupport)

# Implementation of the --disable-O-flag-munging switch.

AC_MSG_CHECKING([whether a -O flag munging is requested])

AC_ARG_ENABLE([O-flag-munging],

              AC_HELP_STRING([--disable-O-flag-munging],

                 [Disable modification of the cc -O flag]),

              [enable_o_flag_munging=$enableval],

              [enable_o_flag_munging=yes])

AC_MSG_RESULT($enable_o_flag_munging)

AM_CONDITIONAL(ENABLE_O_FLAG_MUNGING, test "$enable_o_flag_munging" = "yes")

# Implementation of the --disable-amd64-as-feature-detection switch.

AC_MSG_CHECKING([whether to enable AMD64 as(1) feature detection])

AC_ARG_ENABLE(amd64-as-feature-detection,

              AC_HELP_STRING([--disable-amd64-as-feature-detection],

                 [Disable the auto-detection of AMD64 as(1) features]),

	      amd64_as_feature_detection=$enableval,

              amd64_as_feature_detection=yes)

AC_MSG_RESULT($amd64_as_feature_detection)

AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",

                   [A human readable text with the name of the OS])

# For some systems we know that we have ld_version scripts.

# Use it then as default.

have_ld_version_script=no

case "${host}" in

    *-*-linux*)

	have_ld_version_script=yes

        ;;

    *-*-gnu*)

	have_ld_version_script=yes

        ;;

esac

AC_ARG_ENABLE([ld-version-script],

              AC_HELP_STRING([--enable-ld-version-script],

                             [enable/disable use of linker version script.

                              (default is system dependent)]),

              [have_ld_version_script=$enableval],

              [ : ] )

AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")

AC_DEFINE_UNQUOTED(NAME_OF_DEV_RANDOM, "$NAME_OF_DEV_RANDOM",

                   [defined to the name of the strong random device])

AC_DEFINE_UNQUOTED(NAME_OF_DEV_URANDOM, "$NAME_OF_DEV_URANDOM",

                   [defined to the name of the weaker random device])

###############################

#### Checks for libraries. ####

###############################

#

# gpg-error is required.

#

AM_PATH_GPG_ERROR("$NEED_GPG_ERROR_VERSION")

if test "x$GPG_ERROR_LIBS" = "x"; then

  AC_MSG_ERROR([libgpg-error is needed.

                See ftp://ftp.gnupg.org/gcrypt/libgpg-error/ .])

fi

AC_DEFINE(GPG_ERR_SOURCE_DEFAULT, GPG_ERR_SOURCE_GCRYPT,

          [The default error source for libgcrypt.])

#

# Check whether the GNU Pth library is available.  We require this

# to build the optional gcryptrnd program.

#

AC_ARG_WITH(pth-prefix,

            AC_HELP_STRING([--with-pth-prefix=PFX],

                           [prefix where GNU Pth is installed (optional)]),

     pth_config_prefix="$withval", pth_config_prefix="")

if test x$pth_config_prefix != x ; then

   PTH_CONFIG="$pth_config_prefix/bin/pth-config"

fi

if test "$use_random_daemon" = "yes"; then

  AC_PATH_PROG(PTH_CONFIG, pth-config, no)

  if test "$PTH_CONFIG" = "no"; then

    AC_MSG_WARN([[

***

*** To build the Libgcrypt's random number daemon

*** we need the support of the GNU Portable Threads Library.

*** Download it from ftp://ftp.gnu.org/gnu/pth/

*** On a Debian GNU/Linux system you might want to try

***   apt-get install libpth-dev

***]])

  else

    GNUPG_PTH_VERSION_CHECK([1.3.7])

    if test $have_pth = yes; then

       PTH_CFLAGS=`$PTH_CONFIG --cflags`

       PTH_LIBS=`$PTH_CONFIG --ldflags`

       PTH_LIBS="$PTH_LIBS `$PTH_CONFIG --libs --all`"

       AC_DEFINE(USE_GNU_PTH, 1,

                [Defined if the GNU Portable Thread Library should be used])

       AC_DEFINE(HAVE_PTH, 1,

                [Defined if the GNU Pth is available])

    fi

  fi

fi

AC_SUBST(PTH_CFLAGS)

AC_SUBST(PTH_LIBS)

#

# Check whether pthreads is available

#

if test "$have_w32_system" != yes; then

  AC_CHECK_LIB(pthread,pthread_create,have_pthread=yes)

  if test "$have_pthread" = yes; then

    AC_DEFINE(HAVE_PTHREAD, 1 ,[Define if we have pthread.])

  fi

fi

# Solaris needs -lsocket and -lnsl. Unisys system includes

# gethostbyname in libsocket but needs libnsl for socket.

AC_SEARCH_LIBS(setsockopt, [socket], ,

	[AC_SEARCH_LIBS(setsockopt, [socket], , , [-lnsl])])

AC_SEARCH_LIBS(setsockopt, [nsl])

##################################

#### Checks for header files. ####

##################################

AC_HEADER_STDC

AC_CHECK_HEADERS(unistd.h sys/select.h sys/msg.h)

INSERT_SYS_SELECT_H=

if test x"$ac_cv_header_sys_select_h" = xyes; then

  INSERT_SYS_SELECT_H=" include <sys/select.h>"

fi

AC_SUBST(INSERT_SYS_SELECT_H)

##########################################

#### Checks for typedefs, structures, ####

####  and compiler characteristics.   ####

##########################################

AC_C_CONST

AC_C_INLINE

AC_TYPE_SIZE_T

AC_TYPE_SIGNAL

AC_DECL_SYS_SIGLIST

AC_TYPE_PID_T

GNUPG_CHECK_TYPEDEF(byte, HAVE_BYTE_TYPEDEF)

GNUPG_CHECK_TYPEDEF(ushort, HAVE_USHORT_TYPEDEF)

GNUPG_CHECK_TYPEDEF(ulong, HAVE_ULONG_TYPEDEF)

GNUPG_CHECK_TYPEDEF(u16, HAVE_U16_TYPEDEF)

GNUPG_CHECK_TYPEDEF(u32, HAVE_U32_TYPEDEF)

gl_TYPE_SOCKLEN_T

case "${host}" in

  *-*-mingw32*)

    # socklen_t may or may not be defined depending on what headers

    # are included.  To be safe we use int as this is the actual type.

    FALLBACK_SOCKLEN_T="typedef int gcry_socklen_t;"

    ;;

  *)

    if test ".$gl_cv_socklen_t_equiv" = "."; then

      FALLBACK_SOCKLEN_T="typedef socklen_t gcry_socklen_t;"

    else

      FALLBACK_SOCKLEN_T="typedef ${gl_cv_socklen_t_equiv} gcry_socklen_t;"

    fi

esac

AC_SUBST(FALLBACK_SOCKLEN_T)

#

# Check for __builtin_bswap32 intrinsic.

#

AC_CACHE_CHECK(for __builtin_bswap32,

       [gcry_cv_have_builtin_bswap32],

       [gcry_cv_have_builtin_bswap32=no

        AC_LINK_IFELSE([AC_LANG_PROGRAM([],

          [int x = 0; int y = __builtin_bswap32(x); return y;])],

          [gcry_cv_have_builtin_bswap32=yes])])

if test "$gcry_cv_have_builtin_bswap32" = "yes" ; then

   AC_DEFINE(HAVE_BUILTIN_BSWAP32,1,

             [Defined if compiler has '__builtin_bswap32' intrinsic])

fi

#

# Check for __builtin_bswap64 intrinsic.

#

AC_CACHE_CHECK(for __builtin_bswap64,

       [gcry_cv_have_builtin_bswap64],

       [gcry_cv_have_builtin_bswap64=no

        AC_LINK_IFELSE([AC_LANG_PROGRAM([],

          [long long x = 0; long long y = __builtin_bswap64(x); return y;])],

          [gcry_cv_have_builtin_bswap64=yes])])

if test "$gcry_cv_have_builtin_bswap64" = "yes" ; then

   AC_DEFINE(HAVE_BUILTIN_BSWAP64,1,

             [Defined if compiler has '__builtin_bswap64' intrinsic])

fi

#

# Check for __builtin_ctz intrinsic.

#

AC_CACHE_CHECK(for __builtin_ctz,

       [gcry_cv_have_builtin_ctz],

       [gcry_cv_have_builtin_ctz=no

        AC_LINK_IFELSE([AC_LANG_PROGRAM([],

          [unsigned int x = 0; int y = __builtin_ctz(x); return y;])],

          [gcry_cv_have_builtin_ctz=yes])])

if test "$gcry_cv_have_builtin_ctz" = "yes" ; then

   AC_DEFINE(HAVE_BUILTIN_CTZ, 1,

             [Defined if compiler has '__builtin_ctz' intrinsic])

fi

#

# Check for VLA support (variable length arrays).

#

AC_CACHE_CHECK(whether the variable length arrays are supported,

       [gcry_cv_have_vla],

       [gcry_cv_have_vla=no

        AC_COMPILE_IFELSE([AC_LANG_SOURCE(

          [[void f1(char *, int);

            char foo(int i) {

              char b[(i < 0 ? 0 : i) + 1];

              f1(b, sizeof b); return b[0];}]])],

          [gcry_cv_have_vla=yes])])

if test "$gcry_cv_have_vla" = "yes" ; then

   AC_DEFINE(HAVE_VLA,1, [Defined if variable length arrays are supported])

fi

#

# Check for ELF visibility support.

#

AC_CACHE_CHECK(whether the visibility attribute is supported,

       gcry_cv_visibility_attribute,

       [gcry_cv_visibility_attribute=no