configure.ac
No OneTemporary
Actions

Size

26 KB

Subscribers

None

configure.ac
View Options

	# Configure.ac script for Libgcrypt
	# Copyright (C) 1998, 1999, 2000, 2001, 2002
	# 2003 Free Software Foundation, Inc.
	#
	# 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, write to the Free Software
	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
	#
	# (Process this file with autoconf to produce a configure script.)
	AC_REVISION($Revision$)
	AC_PREREQ(2.52)

	# Version number: Remember to change it immediately after a release
	# but remove a "-cvs" prefix right before a release and append it
	# soon later.

	AC_INIT(libgcrypt, 1.1.44-cvs, bug-libgcrypt@gnupg.org)

	# LT Version numbers, remember to change them just before a release.
	# (Interfaces removed: CURRENT++, AGE=0, REVISION=0)
	# (Interfaces added: CURRENT++, AGE++, REVISION=0)
	# (No interfaces changed: REVISION++)
	LIBGCRYPT_LT_CURRENT=8
	LIBGCRYPT_LT_AGE=1
	LIBGCRYPT_LT_REVISION=0

	NEED_GPG_ERROR_VERSION=0.4


	PACKAGE=$PACKAGE_NAME
	VERSION=$PACKAGE_VERSION

	AC_CONFIG_SRCDIR([src/gcrypt.h])
	AC_CONFIG_AUX_DIR(scripts)
	AC_CANONICAL_TARGET()
	AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
	AM_CONFIG_HEADER(config.h)
	AM_MAINTAINER_MODE

	AH_TOP([
	/* need this, because some autoconf tests rely on this (e.g. stpcpy)
	* and it should be used for new programs */
	#define _GNU_SOURCE 1
	])

	AH_BOTTOM([
	#include "gcrypt-defs.h"
	#define _GCRYPT_IN_LIBGCRYPT 1
	])

	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])

	##########################
	## General definitions. ##
	##########################

	# Used by libgcrypt-config
	LIBGCRYPT_CONFIG_LIBS="-lgcrypt"
	LIBGCRYPT_CONFIG_CFLAGS=""
	LIBGCRYPT_CONFIG_LIBS_PTHREAD="-lgcrypt-pthread"
	LIBGCRYPT_CONFIG_CFLAGS_PTHREAD=""
	LIBGCRYPT_CONFIG_LIBS_PTH="-lgcrypt-pth"
	LIBGCRYPT_CONFIG_CFLAGS_PTH=""

	# Definitions for symmetric ciphers.
	available_ciphers="arcfour blowfish cast5 des aes twofish serpent"
	enabled_ciphers=""

	# Definitions for public-key ciphers.
	available_pubkey_ciphers="dsa elgamal rsa"
	enabled_pubkey_ciphers=""

	# Definitions for message digests.
	available_digests="crc md4 md5 rmd160 sha1 sha256"
	available_digests_64="sha512 tiger"
	enabled_digests=""

	# Definitions for random modules.
	available_random_modules="linux egd unix"
	auto_random_modules="$available_random_modules"

	# Supported thread backends.
	LIBGCRYPT_THREAD_MODULES=""

	# Other definitions.
	print_egd_notice=no

	# Setup some stuff depending on host/target.
	case "${target}" in
	--mingw32*)
	available_random_modules="w32"
	ac_cv_have_dev_random=no
	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--os2emx)
	# 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)
	;;

	--freebsd*)
	# FreeBSD
	CPPFLAGS="$CPPFLAGS -I/usr/local/include"
	LDFLAGS="$LDFLAGS -L/usr/local/lib"
	;;

	--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)
	;;
	*)
	;;
	esac

	# For now we hardcode the use of version scripts. It would be better
	# to write a text for this or even implement this within libtool
	have_ld_version_script=no
	case "${target}" in
	--mingw32*)
	PRINTABLE_OS_NAME="MingW32"
	;;

	i?86-emx-os2 \| i?86--os2emx )
	PRINTABLE_OS_NAME="OS/2"
	;;

	i?86--msdosdjgpp)
	PRINTABLE_OS_NAME="MSDOS/DJGPP"
	;;

	-linux)
	PRINTABLE_OS_NAME="GNU/Linux"
	have_ld_version_script=yes
	;;

	# let that after linux to avoid gnu-linux problems
	-gnu)
	PRINTABLE_OS_NAME="GNU/Hurd"
	have_ld_version_script=yes
	;;

	*)
	PRINTABLE_OS_NAME=`uname -s \|\| echo "Unknown"`
	;;
	esac

	case "${target}" in
	-openbsd \| -netbsd)
	# FIXME: Are these the best flags for OpenBSD?
	NAME_OF_DEV_RANDOM="/dev/srandom"
	NAME_OF_DEV_URANDOM="/dev/urandom"
	# DYNLINK_MOD_CFLAGS="-shared -rdynamic $CFLAGS_PIC -Wl,-Bshareable -Wl,-x"
	;;

	-solaris \| -irix \| -dec-osf )
	NAME_OF_DEV_RANDOM="/dev/random"
	NAME_OF_DEV_URANDOM="/dev/random"
	# DYNLINK_MOD_CFLAGS="-shared $CFLAGS_PIC"
	;;

	*)
	NAME_OF_DEV_RANDOM="/dev/random"
	NAME_OF_DEV_URANDOM="/dev/urandom"
	# -shared is a gcc-ism. Find pic flags from GNUPG_CHECK_PIC.
	# if test -n "$GCC" ; then
	# DYNLINK_MOD_CFLAGS="-shared $CFLAGS_PIC"
	# else
	# DYNLINK_MOD_CFLAGS="$CFLAGS_PIC"
	# fi
	;;
	esac


	AC_C_BIGENDIAN

	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)

	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

	# 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_WARN([No 64-bit types. Disabling TIGER/192, SHA-384, and SHA-512])
	else
	available_digests="$available_digests $available_digests_64"
	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"

	############################
	## 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 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-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 --disable-asm.
	AC_MSG_CHECKING([whether assembler modules are requested])
	AC_ARG_ENABLE([asm],
	AC_HELP_STRING([--disable-asm],
	[Disable 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,
	[ --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 --with-capabilities switch.
	# Check whether we want to use Linux capabilities
	AC_MSG_CHECKING([whether use of capabilities is requested])
	AC_ARG_WITH(capabilities,
	[ --with-capabilities use linux capabilities [default=no]],
	[use_capabilities="$withval"],[use_capabilities=no])
	AC_MSG_RESULT($use_capabilities)

	##############################
	#### Checks for programs. ####
	##############################

	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_AS
	AC_ISC_POSIX
	AC_PROG_INSTALL
	AC_PROG_AWK

	AM_PROG_LIBTOOL

	AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",
	[A human readable text with the name of the OS])
	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. ####
	###############################

	AM_PATH_GPG_ERROR("$NEED_GPG_ERROR_VERSION")
	if test "x$GPG_ERROR_LIBS" = "x"; then
	AC_MSG_ERROR([libgpg-error is needed])
	fi

	AC_DEFINE(GPG_ERR_SOURCE_DEFAULT, GPG_ERR_SOURCE_GCRYPT,
	[The default error source for libgcrypt.])

	# Solaris needs -lsocket and -lnsl. Unisys system includes
	# gethostbyname in libsocket but needs libnsl for socket.
	AC_CHECK_LIB(nsl, gethostbyname)
	AC_CHECK_LIB(socket, socket, ac_need_libsocket=1, ac_try_nsl=1)
	if test x$ac_need_libsocket = x1; then
	LIBS="$LIBS -lsocket"
	fi
	if test x$ac_try_nsl = x1; then
	AC_CHECK_LIB(nsl, gethostbyname, ac_need_libnsl=1)
	if test x$ac_need_libnsl = x1
	then
	LIBS="$LIBS -lnsl"
	fi
	fi

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

	AC_HEADER_STDC
	AC_CHECK_HEADERS(unistd.h 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

	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)

	AC_CHECK_TYPE(socklen_t,,
	[AC_DEFINE_UNQUOTED([socklen_t],
	[int],
	[Define to `int' if unavailable.])],
	[
	#include <sys/types.h>
	#include <sys/socket.h>
	])

	#######################################
	#### Checks for library functions. ####
	#######################################

	AC_FUNC_VPRINTF
	# We have replacements for these in src/missing-string.c
	AC_CHECK_FUNCS(stpcpy strcasecmp)
	# We have replacements for these in src/g10lib.h
	AC_CHECK_FUNCS(strtoul memmove stricmp atexit raise)
	# Other checks
	AC_CHECK_FUNCS(strerror rand mmap getpagesize waitpid wait4)
	AC_CHECK_FUNCS(gettimeofday getrusage gethrtime clock_gettime)

	GNUPG_CHECK_MLOCK

	# Check which thread libraries are supported by the system.
	have_pth=no
	have_pthread=no

	AC_CHECK_LIB(pth,pth_version,have_pth=yes)
	if test "$have_pth" = yes; then
	LIBGCRYPT_CONFIG_LIBS_PTH="$LIBGCRYPT_CONFIG_LIBS_PTH -lpth"
	LIBGCRYPT_THREAD_MODULES="$LIBGCRYPT_THREAD_MODULES pth"
	AC_DEFINE(HAVE_PTH, ,[Define if we have Pth.])
	fi

	AC_CHECK_LIB(pthread,pthread_create,have_pthread=yes)
	if test "$have_pthread" = yes; then
	LIBGCRYPT_CONFIG_LIBS_PTHREAD="$LIBGCRYPT_CONFIG_LIBS_PTHREAD -lpthread"
	else
	AC_CHECK_LIB(c,pthread_create,have_pthread=yes)
	fi
	if test "$have_pthread" = yes; then
	LIBGCRYPT_THREAD_MODULES="$LIBGCRYPT_THREAD_MODULES pthread"
	AC_DEFINE(HAVE_PTHREAD, ,[Define if we have pthread.])
	fi

	AM_CONDITIONAL(HAVE_PTH, test "$have_pth" = "yes")
	AM_CONDITIONAL(HAVE_PTHREAD, test "$have_pthread" = "yes")

	# Check whether we can use Linux capabilities as requested.
	if test "$use_capabilities" = "yes" ; then
	use_capabilities=no
	AC_CHECK_HEADERS(sys/capability.h)
	if test "$ac_cv_header_sys_capability_h" = "yes" ; then
	AC_CHECK_LIB(cap, cap_init, ac_need_libcap=1)
	if test "$ac_cv_lib_cap_cap_init" = "yes"; then
	AC_DEFINE(USE_CAPABILITIES,1,
	[define if capabilities should be used])
	LIBS="$LIBS -lcap"
	use_capabilities=yes
	fi
	fi
	if test "$use_capabilities" = "no" ; then
	AC_MSG_WARN([[
	***
	*** The use of capabilities on this system is not possible.
	*** You need a recent Linux kernel and some patches:
	*** fcaps-2.2.9-990610.patch (kernel patch for 2.2.9)
	*** fcap-module-990613.tar.gz (kernel module)
	*** libcap-1.92.tar.gz (user mode library and utilities)
	*** And you have to configure the kernel with CONFIG_VFS_CAP_PLUGIN
	*** set (filesystems menu). Be warned: This code is really ALPHA.
	***]])
	fi
	fi

	# Check whether a random device is available.
	if test "$try_dev_random" = yes ; then
	AC_CACHE_CHECK(for random device, ac_cv_have_dev_random,
	[if test -r "$NAME_OF_DEV_RANDOM" && test -r "$NAME_OF_DEV_URANDOM" ; then
	ac_cv_have_dev_random=yes; else ac_cv_have_dev_random=no; fi])
	if test "$ac_cv_have_dev_random" = yes; then
	AC_DEFINE(HAVE_DEV_RANDOM,1,
	[defined if the system supports a random device] )
	fi
	else
	AC_MSG_CHECKING(for random device)
	ac_cv_have_dev_random=no
	AC_MSG_RESULT(has been disabled)
	fi

	# Figure out the random modules for this configuration.
	if test "$random" = "default"; then

	# Select default value.
	if test "$ac_cv_have_dev_random" = yes; then
	# Try Linuxish random device.
	random_modules="linux"
	else
	case "${target}" in
	--mingw32\|--cygwin)
	# Windows random device.
	random_modules="w32"
	;;
	*)
	# Build everything, allow to select at runtime.
	random_modules="$auto_random_modules"
	;;
	esac
	fi
	else
	if test "$random" = "auto"; then
	# Build everything, allow to select at runtime.
	random_modules="$auto_random_modules"
	fi
	fi


	#
	# Setup assembler stuff.
	#
	GNUPG_SYS_SYMBOL_UNDERSCORE()
	AC_MSG_CHECKING(for mpi assembler functions)
	if test -f $srcdir/mpi/config.links ; then
	. $srcdir/mpi/config.links
	AC_CONFIG_LINKS("$mpi_ln_list")
	ac_cv_mpi_mod_list="$mpi_mod_list"
	ac_cv_mpi_sflags="$mpi_sflags"
	ac_cv_mpi_config_done="yes"
	AC_MSG_RESULT(done)
	else
	AC_MSG_RESULT(failed)
	AC_MSG_ERROR([mpi/config.links missing!])
	fi
	MPI_MOD_LIST_LO=""
	MPI_MOD_LIST_O=""
	if test "$ac_cv_mpi_mod_list" != ""; then
	for i in $ac_cv_mpi_mod_list; do
	MPI_MOD_LIST_LO="$MPI_MOD_LIST_LO $i.lo"
	MPI_MOD_LIST_O="$MPI_MOD_LIST_O $i.o"
	done
	fi
	AC_SUBST(MPI_MOD_LIST_LO)
	AC_SUBST(MPI_MOD_LIST_O)
	MPI_SFLAGS="$ac_cv_mpi_sflags"
	AC_SUBST(MPI_SFLAGS)

	# Allow users to append something to the version string without
	# flagging it as development version. The user version part is
	# considered everything after a dash.
	changequote(,)#
	tmp_pat='[a-zA-Z]'
	changequote([,])#
	if echo "$VERSION" \| sed 's/-.*//' \| grep "$tmp_pat" >/dev/null ; then
	AC_DEFINE(IS_DEVELOPMENT_VERSION,1,
	[Defined if this is not a regular release])
	fi

	AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)

	GNUPG_CHECK_GNUMAKE

	if test "$GCC" = yes; then
	if test "$MAINTAINER_MODE" = "yes"; then
	CFLAGS="$CFLAGS -Wall -Wcast-align -Wshadow -Wstrict-prototypes"
	else
	CFLAGS="$CFLAGS -Wall"
	fi
	fi

	#
	# Make the version number in src/gcrypt.h the same as the one here.
	# (this is easier than to have a *.in file just for one substitution)
	#
	GNUPG_FIX_HDR_VERSION([src/gcrypt.h], GCRYPT_VERSION)

	AC_SUBST(LIBGCRYPT_CONFIG_LIBS)
	AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS)
	AC_SUBST(LIBGCRYPT_CONFIG_LIBS_PTHREAD)
	AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS_PTHREAD)
	AC_SUBST(LIBGCRYPT_CONFIG_LIBS_PTH)
	AC_SUBST(LIBGCRYPT_CONFIG_CFLAGS_PTH)
	AC_SUBST(LIBGCRYPT_THREAD_MODULES)

	AC_CONFIG_COMMANDS([gcrypt-defs],[[
	chmod +x src/libgcrypt-config
	cat >gcrypt-defs.tmp <<G10EOF
	/* Generated automatically by configure */
	#ifdef HAVE_DRIVE_LETTERS
	#define GNUPG_LOCALEDIR "c:/lib/gnupg/locale"
	#define GNUPG_LIBDIR "c:/lib/gnupg"
	#define GNUPG_DATADIR "c:/lib/gnupg"
	#define GNUPG_HOMEDIR "c:/gnupg-test"
	#else
	#define GNUPG_LOCALEDIR "${prefix}/${DATADIRNAME}/locale"
	#define GNUPG_LIBDIR "${libdir}/gnupg"
	#define GNUPG_DATADIR "${datadir}/gnupg"
	#ifdef __VMS
	#define GNUPG_HOMEDIR "/SYS\$LOGIN/gnupg"
	#else
	#define GNUPG_HOMEDIR "~/.gnupg-test"
	#endif
	#endif
	G10EOF
	if cmp -s gcrypt-defs.h gcrypt-defs.tmp 2>/dev/null; then
	echo "gcrypt-defs.h is unchanged"
	rm -f gcrypt-defs.tmp
	else
	rm -f gcrypt-defs.h
	mv gcrypt-defs.tmp gcrypt-defs.h
	echo "gcrypt-defs.h created"
	fi
	]],[[
	prefix=$prefix
	exec_prefix=$exec_prefix
	libdir=$libdir
	datadir=$datadir
	DATADIRNAME=$DATADIRNAME
	]])

	#####################
	#### Conclusion. ####
	#####################

	# Define conditional sources and config.h symbols depending on the
	# selected ciphers, pubkey-ciphers, digests and random modules.

	LIST_MEMBER(arcfour, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS arcfour.lo"
	AC_DEFINE_UNQUOTED(USE_ARCFOUR, $found, [Defined if this module should be included])
	LIST_MEMBER(blowfish, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS blowfish.lo"
	AC_DEFINE_UNQUOTED(USE_BLOWFISH, $found, [Defined if this module should be included])
	LIST_MEMBER(cast5, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS cast5.lo"
	AC_DEFINE_UNQUOTED(USE_CAST5, $found, [Defined if this module should be included])
	LIST_MEMBER(des, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS des.lo"
	AC_DEFINE_UNQUOTED(USE_DES, $found, [Defined if this module should be included])
	LIST_MEMBER(aes, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS rijndael.lo"
	AC_DEFINE_UNQUOTED(USE_AES, $found, [Defined if this module should be included])
	LIST_MEMBER(twofish, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS twofish.lo"
	AC_DEFINE_UNQUOTED(USE_TWOFISH, $found, [Defined if this module should be included])
	LIST_MEMBER(serpent, $enabled_ciphers)
	test "$found" = "1" && GCRYPT_CIPHERS="$GCRYPT_CIPHERS serpent.lo"
	AC_DEFINE_UNQUOTED(USE_SERPENT, $found, [Defined if this module should be included])

	LIST_MEMBER(dsa, $enabled_pubkey_ciphers)
	test "$found" = "1" && GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS dsa.lo"
	AC_DEFINE_UNQUOTED(USE_DSA, $found, [Defined if this module should be included])
	LIST_MEMBER(rsa, $enabled_pubkey_ciphers)
	test "$found" = "1" && GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS rsa.lo"
	AC_DEFINE_UNQUOTED(USE_RSA, $found, [Defined if this module should be included])
	LIST_MEMBER(elgamal, $enabled_pubkey_ciphers)
	test "$found" = "1" && GCRYPT_PUBKEY_CIPHERS="$GCRYPT_PUBKEY_CIPHERS elgamal.lo"
	AC_DEFINE_UNQUOTED(USE_ELGAMAL, $found, [Defined if this module should be included])

	LIST_MEMBER(crc, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS crc.lo"
	AC_DEFINE_UNQUOTED(USE_CRC, $found, [Defined if this module should be included])
	LIST_MEMBER(md4, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS md4.lo"
	AC_DEFINE_UNQUOTED(USE_MD4, $found, [Defined if this module should be included])
	LIST_MEMBER(md5, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS md5.lo"
	AC_DEFINE_UNQUOTED(USE_MD5, $found, [Defined if this module should be included])
	LIST_MEMBER(sha1, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha1.lo"
	AC_DEFINE_UNQUOTED(USE_SHA1, $found, [Defined if this module should be included])
	LIST_MEMBER(sha256, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha256.lo"
	AC_DEFINE_UNQUOTED(USE_SHA256, $found, [Defined if this module should be included])
	LIST_MEMBER(sha512, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS sha512.lo"
	AC_DEFINE_UNQUOTED(USE_SHA512, $found, [Defined if this module should be included])
	LIST_MEMBER(tiger, $enabled_digests)
	test "$found" = "1" && GCRYPT_DIGESTS="$GCRYPT_DIGESTS tiger.lo"
	AC_DEFINE_UNQUOTED(USE_TIGER, $found, [Defined if this module should be included])

	# rmd160 should be included always.
	GCRYPT_DIGESTS="$GCRYPT_DIGESTS rmd160.lo"
	AM_CONDITIONAL(USE_RMD160, true)
	AC_DEFINE_UNQUOTED(USE_RMD160, 1, [Defined if this module should be included])

	LIST_MEMBER(linux, $random_modules)
	test "$found" = "1" && GCRYPT_RANDOM="$GCRYPT_RANDOM rndlinux.lo"
	AC_DEFINE_UNQUOTED(USE_RNDLINUX, $found, [Defined if the /dev/random based RNG should be used.])

	LIST_MEMBER(unix, $random_modules)
	test "$found" = "1" && GCRYPT_RANDOM="$GCRYPT_RANDOM rndunix.lo"
	AC_DEFINE_UNQUOTED(USE_RNDUNIX, $found, [Defined if the default Unix RNG should be used.])
	if test "$found" = "1"; then
	print_egd_notice=yes
	fi

	LIST_MEMBER(egd, $random_modules)
	test "$found" = "1" && GCRYPT_RANDOM="$GCRYPT_RANDOM rndegd.lo"
	AC_DEFINE_UNQUOTED(USE_RNDEGD, $found, [Defined if the EGD based RNG should be used.])

	LIST_MEMBER(w32, $random_modules)
	test "$found" = "1" && GCRYPT_RANDOM="$GCRYPT_RANDOM rndw32.lo"
	AC_DEFINE_UNQUOTED(USE_RNDW32, $found, [Defined if the Windows specific RNG should be used.])

	AC_SUBST([GCRYPT_CIPHERS])
	AC_SUBST([GCRYPT_PUBKEY_CIPHERS])
	AC_SUBST([GCRYPT_DIGESTS])
	AC_SUBST([GCRYPT_RANDOM])

	AC_SUBST(LIBGCRYPT_CIPHERS, $enabled_ciphers)
	AC_SUBST(LIBGCRYPT_PUBKEY_CIPHERS, $enabled_pubkey_ciphers)
	AC_SUBST(LIBGCRYPT_DIGESTS, $enabled_digests)

	AC_CONFIG_FILES([
	Makefile
	mpi/Makefile
	cipher/Makefile
	doc/Makefile
	src/Makefile
	src/libgcrypt-config
	tests/Makefile
	w32-dll/Makefile
	])
	AC_OUTPUT

	# Give some feedback
	echo

	if test "$print_egd_notice" = "yes"; then
	cat <<G10EOF

	The performance of the Unix random gatherer module (rndunix) is not
	very good and it does not keep the entropy pool over multiple
	invocations of GnuPG. The suggested way to overcome this problem is
	to use the

	Entropy Gathering Daemon (EGD)

	which provides a entropy source for the whole system. It is written
	in Perl and available at the GnuPG FTP servers. To enable EGD you
	should rerun configure with the option "--enable-static-rnd=egd".
	For more information consult the GnuPG webpages:

	http://www.gnupg.org/download.html#egd

	G10EOF
	fi

	warn=""
	for file in "random_modules"; do
	case "$file" in rndunix \| rndw32) warn="$warn $file";; esac
	done
	if test -n "$warn"; then
	echo "Please note that you are building a version of Libgcrypt with"
	echo " $warn"
	echo "included. These parts are licensed under the GPL and thus the"
	echo "use of this library has to comply with the conditions of the GPL."
	fi

	# Give some feedback
	echo " Configured for: $PRINTABLE_OS_NAME ($target)"
	echo

File Metadata

Mime Type: text/x-c
Expires: Mon, Dec 23, 5:27 PM (2 h, 11 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: d4/1b/6ce04edc3a6ef69014e328b0de28

configure.acNo OneTemporaryActions

configure.acView Options

File Metadata

Event Timeline

configure.ac
No OneTemporary
Actions

configure.ac
View Options