path: root/configure.in

dnl Process this file with autoconf to produce a configure script.

dnl Copyright (C) 2004 Simon Josefsson
dnl Copyright (C) 2000, 2001, 2002, 2003, 2004 Nikos Mavroyanopoulos
dnl
dnl This file is part of GNU TLS.
dnl
dnl GNU TLS is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU Lesser General Public License as
dnl published by the Free Software Foundation; either version 2.1 of
dnl the License, or (at your option) any later version.
dnl
dnl GNU TLS is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
dnl Lesser General Public License for more details.
dnl
dnl You should have received a copy of the GNU Lesser General Public
dnl License along with GNU TLS; if not, write to the Free Software
dnl Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
dnl 02111-1307, USA

AC_INIT

AC_PREREQ(2.57)

AC_CANONICAL_TARGET([])
AC_DEFINE_UNQUOTED(T_CPU, "$target_cpu", [CPU name])
AC_DEFINE_UNQUOTED(T_VENDOR, "$target_vendor", [Vendor name])
AC_DEFINE_UNQUOTED(T_OS, "$target_os", [OS name])

dnl Gnutls Version
GNUTLS_MAJOR_VERSION=1
GNUTLS_MINOR_VERSION=1
GNUTLS_MICRO_VERSION=17
GNUTLS_VERSION=$GNUTLS_MAJOR_VERSION.$GNUTLS_MINOR_VERSION.$GNUTLS_MICRO_VERSION

AC_DEFINE_UNQUOTED(GNUTLS_VERSION, "$GNUTLS_VERSION", [version of gnutls])

GNUTLS_GCRYPT_VERSION=1:1.2.0
GNUTLS_LIBTASN1_VERSION=0.2.10
AC_DEFINE_UNQUOTED(GNUTLS_GCRYPT_VERSION, "$GNUTLS_GCRYPT_VERSION", [version of gcrypt])
AC_DEFINE_UNQUOTED(GNUTLS_LIBTASN1_VERSION, "$GNUTLS_LIBTASN1_VERSION", [version of libtasn1])

AM_INIT_AUTOMAKE(gnutls, $GNUTLS_VERSION, [version of gnutls])
AM_CONFIG_HEADER(config.h)
AB_INIT

dnl This is the library version
GNUTLS_MOST_RECENT_INTERFACE=13
GNUTLS_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER=$GNUTLS_MICRO_VERSION
GNUTLS_OLDEST_INTERFACE=12


AC_SUBST(GNUTLS_MAJOR_VERSION)
AC_SUBST(GNUTLS_MINOR_VERSION)
AC_SUBST(GNUTLS_MICRO_VERSION)
AC_SUBST(GNUTLS_VERSION)

AC_SUBST(GNUTLS_MOST_RECENT_INTERFACE)
AC_SUBST(GNUTLS_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER)
AC_SUBST(GNUTLS_OLDEST_INTERFACE)

LT_CURRENT=$GNUTLS_MOST_RECENT_INTERFACE
LT_REVISION=$GNUTLS_CURRENT_INTERFACE_IMPLEMENTATION_NUMBER
LT_AGE=`expr $GNUTLS_MOST_RECENT_INTERFACE - $GNUTLS_OLDEST_INTERFACE`
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)

case "${target}" in
    *-*-mingw32*)
        LIBS="$LIBS -lwsock32"
        ;;
    *)
      ;;
esac

dnl In order to use the reentrant libc functions.
dnl I hope it is portable enough.
CFLAGS="${CFLAGS} -D_REENTRANT -D_THREAD_SAFE"

opt_dmalloc_mode=no
AC_MSG_CHECKING([whether in dmalloc mode])
AC_ARG_ENABLE(dmalloc-mode,
[  --enable-dmalloc-mode      enable dmalloc mode],
opt_dmalloc_mode=$enableval)
AC_MSG_RESULT($opt_dmalloc_mode)

opt_efence_mode=no
AC_MSG_CHECKING([whether in electric fence mode])
AC_ARG_ENABLE(efence-mode,
[  --enable-efence-mode       enable electric fence mode],
opt_efence_mode=$enableval)
AC_MSG_RESULT($opt_efence_mode)

opt_developer_mode=no
AC_MSG_CHECKING([whether in developer mode])
AC_ARG_ENABLE(developer-mode,
[  --enable-developer-mode    enable developer mode],
opt_developer_mode=$enableval)
AC_MSG_RESULT($opt_developer_mode)

opt_profiler_mode=no
AC_MSG_CHECKING([whether in profile mode])
AC_ARG_ENABLE(profile-mode,
[  --enable-profile-mode      enable profiler],
opt_profiler_mode=$enableval)
AC_MSG_RESULT($opt_profiler_mode)

AC_MSG_RESULT([***
*** Checking for compilation programs...
])

SAVED_CFLAGS="${CFLAGS}"

AC_PROG_CC

CFLAGS="${SAVED_CFLAGS}"

AC_PROG_LN_S


dnl Checks for programs.
AC_PROG_INSTALL

dnl AC_PROG_MAKE_SET


AC_MSG_RESULT([***
*** Detecting compiler options...
])

gl_EARLY

AC_C_CONST
AC_C_INLINE

AC_MSG_CHECKING([whether C99 macros are supported])
AC_TRY_COMPILE(,[ 
#define test_mac(...) 
int z,y,x;
test_mac(x,y,z);
return 0;
], 
dnl ***** OK
AC_DEFINE(C99_MACROS, 1, [C99 macros are supported])
AC_MSG_RESULT(yes),
dnl ***** NOT FOUND
AC_MSG_RESULT(no)
AC_MSG_WARN([C99 macros are not supported by your compiler. This may
affect compiling.])
)

if test $ac_cv_c_compiler_gnu != no; then

	if test x$opt_developer_mode = xyes; then
	  CFLAGS="${CFLAGS} -g -Wno-format-y2k -Wall -Wcast-align -W -Wpointer-arith -Wchar-subscripts -Wformat-security -Wmissing-braces -Winline -Wstrict-prototypes"
	else
	  CFLAGS="${CFLAGS} -O2 -finline-functions"
	fi

	if test x$opt_dmalloc_mode = xyes; then
	  AC_CHECK_LIB( dmalloc, main)
	  AC_DEFINE(USE_DMALLOC, 1, [enable the use of dmalloc])
	else
		if test x$opt_efence_mode = xyes; then
		  AC_CHECK_LIB( efence, main)
		  AC_DEFINE(USE_EFENCE, 1, [use electric fence])
		fi
	fi


	AC_MSG_CHECKING([whether we have GNU assembler])

	GAS=`as --version < /dev/null 2>/dev/null | grep GNU`
	if test "$GAS"; then
	  CFLAGS="${CFLAGS} -pipe"
	  AC_MSG_RESULT(yes)
	else
	  AC_MSG_RESULT(no)
	fi
fi


AC_MSG_RESULT([***
*** Detecting C library capabilities...
])

AC_HEADER_STDC
AC_HEADER_TIME
AC_CHECK_HEADERS(unistd.h strings.h stddef.h alloca.h)
AC_CHECK_HEADERS(sys/stat.h sys/types.h sys/socket.h)
AC_CHECK_HEADERS(errno.h sys/time.h time.h)
AC_CHECK_HEADERS(math.h limits.h float.h stdarg.h)
dnl opencdk
AC_CHECK_HEADERS(netdb.h)
AC_CHECK_FUNCS(vasprintf isascii memmove strnstr mmap gmtime_r inet_ntop,,)
AC_FUNC_ALLOCA


AC_MSG_RESULT([***
*** Detecting system's parameters...
])

AC_CHECK_SIZEOF(unsigned long, 4)
AC_CHECK_SIZEOF(unsigned int, 4)
AC_CHECK_SIZEOF(unsigned short, 2)
AC_CHECK_SIZEOF(unsigned char, 1)
AC_CHECK_SIZEOF(unsigned char*, 4)

AC_CHECK_TYPES(ptrdiff_t,,, [
# include <sys/types.h>
# include <stddef.h>
])

AC_CHECK_TYPES(uint,,, [
# include <sys/types.h>
])

AC_CHECK_TYPE(size_t,
DEFINE_SIZE_T="#include <sys/types.h>"
AC_SUBST( DEFINE_SIZE_T)
,
AC_DEFINE(NO_SIZE_T, 1, [no size_t type was found])
DEFINE_SIZE_T="typedef unsigned int size_t;"
AC_SUBST( DEFINE_SIZE_T)
,[
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
])

AC_CHECK_TYPE(ssize_t,
DEFINE_SIZE_T="#include <sys/types.h>"
AC_SUBST( DEFINE_SSIZE_T)
,
AC_DEFINE(NO_SSIZE_T, 1, [no ssize_t type was found])
DEFINE_SSIZE_T="typedef int ssize_t;"
AC_SUBST( DEFINE_SSIZE_T)
,[
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
])

AC_CHECK_TYPE(time_t,
 DEFINE_TIME_T="#include <time.h>"
 AC_SUBST( DEFINE_TIME_T)
 ,
  AC_CHECK_TYPE(time_t,
   DEFINE_TIME_T="#include <sys/time.h>"
   AC_SUBST( DEFINE_TIME_T)
   ,
    DEFINE_TIME_T="typedef unsigned int time_t;"
    AC_SUBST( DEFINE_TIME_T)
    AC_DEFINE(NO_TIME_T, 1, [no time_t type was found]),
  [
   #include <sys/time.h>
  ]
  )
,
[
 #include <time.h>
]
)

AC_C_BIGENDIAN

AC_CHECK_TYPE([socklen_t],, [AC_DEFINE([socklen_t], [size_t],
              [Define to `size_t' if `socklen_t' is missing.])], [
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
])

AC_MSG_RESULT([***
*** Checking for external libraries...
])

AM_PATH_LIBGCRYPT($GNUTLS_GCRYPT_VERSION,,
 	AC_MSG_ERROR([[
***  
*** libgcrypt was not found. You may want to get it from
*** ftp://ftp.gnupg.org/gcrypt/libgcrypt/
***
]]))
dnl Can't disable - gnutls depends on gcrypt
AC_DEFINE(USE_GCRYPT, 1, [use gcrypt])

AC_MSG_CHECKING([whether to disable SRP authentication support])
AC_ARG_ENABLE( srp-authentication, [  --disable-srp-authentication     Disable the SRP authentication support],
 ac_enable_srp=no
)
if test x$ac_enable_srp != xno; then
 AC_MSG_RESULT(no)
 AC_DEFINE(ENABLE_SRP, 1, [enable SRP authentication])
else
 AC_MSG_RESULT(yes)
fi

AC_MSG_CHECKING([whether to disable anonymous authentication support])
AC_ARG_ENABLE( anon-authentication, [  --disable-anon-authentication    Disable the anonymous authentication support],
 ac_enable_anon=no
)
if test x$ac_enable_anon != xno; then
 AC_MSG_RESULT(no)
 AC_DEFINE(ENABLE_ANON, 1, [enable anonymous authentication])
else
 AC_MSG_RESULT(yes)
fi

AC_MSG_CHECKING([whether to disable extra PKI stuff])
AC_ARG_ENABLE( extra-pki, [  --disable-extra-pki              only enable the basic PKI stuff],
 ac_enable_pki=no
)
if test x$ac_enable_pki != xno; then
 AC_MSG_RESULT(no)
 AC_DEFINE(ENABLE_PKI, 1, [whether to include all the PKCS #x stuff and other PKI stuff])
else
 AC_MSG_RESULT(yes)
fi


dnl Check whether to disable OpenPGP authentication completely
dnl from libgnutls-extra.

ac_enable_openpgp=yes
AC_MSG_CHECKING([whether to disable OpenPGP Certificate authentication support])
AC_ARG_ENABLE( openpgp-authentication, [  --disable-openpgp-authentication Disable the OpenPGP authentication support],
 ac_enable_openpgp=no
)

if test x$ac_enable_openpgp = xno; then
 AC_MSG_RESULT(yes)
else
 AC_DEFINE(USE_OPENPGP, 1, [use openpgp authentication])
 AC_MSG_RESULT(no)
fi

AM_CONDITIONAL(ENABLE_OPENPGP, test "$ac_enable_openpgp" = "yes")

dnl Test whether to use the included opencdk library
dnl 
if test x$ac_enable_openpgp = xyes; then
 AC_ARG_WITH(included-opencdk,
 	[  --with-included-opencdk Use the included opencdk],
  ac_enable_included_opencdk=$withval, 
  ac_enable_included_opencdk=no
  )

if test x$ac_enable_included_opencdk = xno;then 
  AM_PATH_LIBOPENCDK( 0.5.5, ,
   ac_enable_included_opencdk=yes
   AC_MSG_WARN([[
***
*** libopencdk 0.5.5 was not found. You may want to get it from
*** ftp://ftp.gnutls.org/pub/gnutls/opencdk/
***
*** Will use the included opencdk.
***
]])
)
fi

AC_MSG_CHECKING([whether to use the included opencdk])
AC_MSG_RESULT($ac_enable_included_opencdk)

fi

AM_CONDITIONAL(ENABLE_INCLUDED_OPENCDK, test "$ac_enable_included_opencdk" = "yes")


ac_enable_openssl=yes
AC_MSG_CHECKING([whether to disable OpenSSL compatibility layer])
AC_ARG_ENABLE( openssl-compatibility, [  --disable-openssl-compatibility Disable the OpenSSL compatibility support],
 ac_enable_openssl=no
)
if test x$ac_enable_openssl != xno; then
 AC_MSG_RESULT(no)
else
 AC_MSG_RESULT(yes)
fi

AM_CONDITIONAL(ENABLE_OPENSSL, test "$ac_enable_openssl" = "yes")


AC_ARG_WITH(included-libtasn1,
	[  --with-included-libtasn1 Use the included libtasn1],
minitasn1_enabled=yes, 
minitasn1_enabled=no)

if test x$minitasn1_enabled = xno; then
AM_PATH_LIBTASN1($GNUTLS_LIBTASN1_VERSION,,
 minitasn1_enabled=yes
 AC_MSG_WARN([[
*** 
*** LibtASN1 ${GNUTLS_LIBTASN1_VERSION} was not found. Will use the included one.
]]))
fi

SAVED_LIBS=$LIBS

AC_MSG_CHECKING([whether to use the included minitasn1])
AC_MSG_RESULT($minitasn1_enabled)

dnl CHECK FOR THE LIBTASN1 LIBRARY or use the included one
dnl

AM_CONDITIONAL(ENABLE_MINITASN1, test "$minitasn1_enabled" = "yes")


dnl Check for libcfg+

AC_ARG_WITH(included-libcfg,
	[  --with-included-libcfg   Use the included libcfg+ (certtool only)],
libcfg_enabled=$withval, 
libcfg_enabled=no

dnl We search for libcfg+ which is used by certtool
dnl
AC_CHECK_LIB( cfg+, cfg_get_context,:, 
 libcfg_enabled=yes
AC_MSG_WARN([[
*** 
*** Libcfg+ was not found. Will use the included one.]])))

AM_CONDITIONAL(HAVE_LIBCFG, test "$libcfg_enabled" = "no")
LIBS=$SAVED_LIBS

AC_MSG_CHECKING([whether to use the included libcfg])
AC_MSG_RESULT($libcfg_enabled)


dnl CHECK FOR ZLIB SUPPORT
dnl

AC_MSG_CHECKING([whether to include zlib compression support])

AC_ARG_WITH( zlib, [  --without-zlib          disable zlib compression support],
 ac_zlib=$withval,
 ac_zlib=yes
)

if test x$ac_zlib != xno; then
 AC_MSG_RESULT(yes)
 AC_CHECK_LIB(z, compress,,AC_MSG_WARN(
*** 
*** ZLIB was not found. You will not be able to use ZLIB compression.))
else
 AC_MSG_RESULT(no)
fi



dnl CHECK FOR LZO SUPPORT (whether to use the included one)
dnl

minilzo_enabled=no
use_lzo=yes
AC_ARG_WITH(lzo,
	[  --without-lzo           do not use lzo compression],
 use_lzo=no,
 use_lzo=yes
)

AC_MSG_CHECKING([whether to include lzo compression support])
AC_MSG_RESULT($use_lzo)

if test x$use_lzo = xyes; then

AC_DEFINE(USE_LZO, 1, [whether to use the lzo compression])

AC_ARG_WITH(included-lzo,
	[  --with-included-lzo     include minilzo in libgnutls-extra],
 minilzo_enabled=$withval,
 minilzo_enabled=no
)

AC_MSG_CHECKING([whether to use the included lzo compression library])

AC_MSG_RESULT($minilzo_enabled)

if test x$minilzo_enabled = xno; then
AC_CHECK_LIB( lzo, lzo1x_1_compress, minilzo_enabled=no, 
 minilzo_enabled=yes
 AC_MSG_WARN(
*** 
*** Liblzo was not found. Will use the included minilzo.))
fi

if test x"$minilzo_enabled" = xyes; then
AC_DEFINE(USE_MINILZO, 1, [whether to use the included minilzo])
else
LZO_LIBS=-llzo
AC_SUBST(LZO_LIBS)
fi

dnl use lzo
fi

AM_CONDITIONAL(USE_LZO, test "$use_lzo" = "yes")
AM_CONDITIONAL(ENABLE_INCLUDED_LZO, test "$minilzo_enabled" = "yes")

AC_MSG_RESULT([***
*** Setting up gnulib compatbility files...
])

gl_SOURCE_BASE(gl)
gl_M4_BASE(gl/m4)
gl_MODULES(getline error exit progname)
gl_INIT

AC_MSG_RESULT([***
*** Detecting options for shared libraries...
])
AM_PROG_LIBTOOL

dnl This is after AM_PROG_LIBTOOL so that the LD variable
dnl has been set.

AC_MSG_CHECKING([whether we have GNU ld or compatible])

GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
if test "$GLD"; then
have_ld_version_script=yes
  AC_MSG_RESULT(yes)
else
have_ld_version_script=no
  AC_MSG_RESULT(no)
AC_MSG_WARN(***
*** You may want to rerun configure using --with-gnu-ld to enable versioned symbols.
)
fi

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


LIBGNUTLS_LIBS="$LIBS -L${libdir} -lgnutls $LIBTASN1_LIBS $LIBGCRYPT_LIBS"
LIBGNUTLS_CFLAGS="$LIBGCRYPT_CFLAGS $LIBTASN1_CFLAGS -I${includedir}"

CFLAGS="${CFLAGS} ${LIBGCRYPT_CFLAGS}"

AC_SUBST(LIBGNUTLS_LIBS)
AC_SUBST(LIBGNUTLS_CFLAGS)

SERV_LIBS="$LIBS $SERV_LIBS"
AC_SUBST(SERV_LIBS)

LIBGNUTLS_EXTRA_LIBS="-L${libdir} -lgnutls-extra $LIBOPENCDK_LIBS $LZO_LIBS $LIBGNUTLS_LIBS"
LIBGNUTLS_EXTRA_CFLAGS="$LIBOPENCDK_CFLAGS -I${includedir}"

AC_SUBST(LIBGNUTLS_EXTRA_LIBS)
AC_SUBST(LIBGNUTLS_EXTRA_CFLAGS)

if test $ac_cv_c_compiler_gnu != no; then

	if test x$opt_profiler_mode = xyes; then
	  AC_CHECK_PROG(FC_OK, fc-config, yes, no)
	  if test x$FC_OK = xyes; then
   	        CFLAGS="${CFLAGS} `fc-config --cflags`"
		LIBS="$LIBS `fc-config --libs`"
	  else
AC_MSG_WARN(***
*** You must install libfc in order to enable profiling. http://www710.univ-lyon1.fr/~yperret/fnccheck/profiler.html
)
	  fi
	fi
fi


AC_CONFIG_FILES(lib/gnutls.h.in)

AC_CONFIG_COMMANDS([includes/gnutls/gnutls.h],[[
 test -f lib/gnutls.h.in || (echo "Could not generate includes/gnutls/gnutls.h" && exit 1)
 cat lib/gnutls.h.in > includes/gnutls/gnutls.h
 cat $srcdir/lib/gnutls_ui.h >> includes/gnutls/gnutls.h
 echo "" >> includes/gnutls/gnutls.h
 cat $srcdir/lib/gnutls_errors_int.h | grep -v _INT_ >> includes/gnutls/gnutls.h
 echo "" >> includes/gnutls/gnutls.h
 echo "#ifdef __cplusplus" >> includes/gnutls/gnutls.h
 echo "}" >> includes/gnutls/gnutls.h
 echo "#endif" >> includes/gnutls/gnutls.h
 echo "#endif /* GNUTLS_H */" >> includes/gnutls/gnutls.h
 echo "" >> includes/gnutls/gnutls.h
 chmod +x lib/libgnutls-config
 chmod +x libextra/libgnutls-extra-config
]],[[]])

AC_CONFIG_FILES([Makefile src/Makefile libextra/Makefile lib/Makefile \
libextra/openpgp/Makefile libextra/opencdk/Makefile \
lib/libgnutls-config libextra/libgnutls-extra-config \
doc/Makefile src/x509/Makefile src/srp/Makefile src/openpgp/Makefile \
src/cfg/Makefile src/cfg/platon/Makefile src/cfg/platon/str/Makefile \
doc/scripts/Makefile lib/minitasn1/Makefile lib/x509/Makefile \
includes/Makefile includes/gnutls/Makefile doc/manpages/Makefile \
gl/Makefile tests/Makefile])

AC_OUTPUT