configure.in

dnl
dnl Copyright 1998,1999 The OpenLDAP Foundation.  All Rights Reserved.
dnl 
dnl Redistribution and use in source and binary forms are permitted only
dnl as authorized by the OpenLDAP Public License.  A copy of this
dnl license is available at http://www.OpenLDAP.org/license.html or
dnl in file LICENSE in the top-level directory of the distribution.
dnl

dnl Disable config.cache!
define([AC_CACHE_LOAD], )dnl
define([AC_CACHE_SAVE], )dnl

dnl Configure.in for OpenLDAP
AC_INIT(build/version)dnl
AC_CONFIG_AUX_DIR(build)dnl

OL_VERSION=`cat $ac_aux_dir/version`
if test -z "$OL_VERSION"; then
	AC_MSG_ERROR([could not determine version])
fi

dnl ----------------------------------------------------------------
dnl Determine host platform
dnl		we try not to use this for much
AC_CANONICAL_SYSTEM

AM_INIT_AUTOMAKE(OpenLDAP,[$OL_VERSION], [no defines])dnl
AC_SUBST(PACKAGE)
AC_SUBST(VERSION)
AC_DEFINE_UNQUOTED(OPENLDAP_PACKAGE,"$PACKAGE",Package)
AC_DEFINE_UNQUOTED(OPENLDAP_VERSION,"$VERSION",Version)

dnl We use autoconf features new to 2.13.
dnl 	aclocal.m4 should be built using aclocal from automake 1.4
AC_PREREQ(2.13)dnl Required Autoconf version

AC_CONFIG_HEADER(include/portable.h include/ldap_features.h include/lber_types.h)dnl

dnl
dnl Start Args
AC_MSG_CHECKING(configure arguments)
AC_PREFIX_DEFAULT(/usr/local)

top_builddir=`pwd`
AC_SUBST(top_builddir)dnl

AC_DEFINE(HAVE_MKVERSION, 1, [define this if you have mkversion])

ldap_subdir="openldap"

AC_ARG_WITH(subdir, [  --with-subdir=DIR change default subdirectory used for installs], [
	if test "$withval" = "no"; then
		ldap_subdir=""
	elif test "$withval" != "yes"; then
		ldap_subdir="$withval"
	fi
])dnl

AC_SUBST(ldap_subdir)dnl

OL_ARG_ENABLE(debug,[  --enable-debug 	enable debugging], yes)dnl
dnl ol_enable_syslog=no
OL_ARG_ENABLE(syslog,[  --enable-syslog	enable syslog support], auto)dnl
OL_ARG_ENABLE(proctitle,[  --enable-proctitle	enable proctitle support], yes)dnl
OL_ARG_ENABLE(cache,[  --enable-cache	enable caching], yes)dnl
OL_ARG_ENABLE(dns,[  --enable-dns		enable V2 DNS  extension], no)dnl
OL_ARG_ENABLE(referrals,[  --enable-referrals	enable V2 Referrals extension], yes)dnl
OL_ARG_ENABLE(cldap,[  --enable-cldap	enable connectionless ldap], no)dnl
OL_ARG_ENABLE(x_compile,[  --enable-x-compile	enable cross compiling],
	no, [yes no])dnl

dnl General "with" options
OL_ARG_ENABLE(dmalloc,[  --enable-dmalloc	enable debug malloc support], no)dnl

OL_ARG_WITH(kerberos,[  --with-kerberos	with Kerberos support],
	auto, [auto k5 k4 afs yes no])
OL_ARG_WITH(readline,[  --with-readline  with readline support],
	auto, [auto yes no] )
OL_ARG_WITH(threads,[  --with-threads	use threads],
	auto, [auto posix mach lwp yes no manual] )
OL_ARG_WITH(tls,[  --with-tls  with TLS/SSL support],
	auto, [auto ssleay openssl yes no] )
OL_ARG_WITH(yielding_select,[  --with-yielding-select	with implicitly yielding select],
	auto, [auto yes no manual] )

dnl Server options

dnl LDAPD OPTIONS
AC_ARG_WITH(xxldapdoptions,[LDAPD Options:])
OL_ARG_ENABLE(ldapd,[  --enable-ldapd	enable building ldapd], no)dnl

dnl SLAPD OPTIONS
AC_ARG_WITH(xxslapdoptions,[SLAPD Options:])
OL_ARG_ENABLE(slapd,[  --enable-slapd	enable building slapd], yes)dnl
OL_ARG_ENABLE(cleartext,[    --enable-cleartext	enable cleartext passwords], yes)dnl
OL_ARG_ENABLE(crypt,[    --enable-crypt	enable crypt(3) passwords], auto)dnl
OL_ARG_ENABLE(modules,[    --enable-modules	enable dynamic module support], no)dnl
OL_ARG_ENABLE(phonetic,[    --enable-phonetic	enable phonetic/soundex], no)dnl
OL_ARG_ENABLE(rlookups,[    --enable-rlookups	enable reverse lookups], auto)dnl
OL_ARG_ENABLE(wrappers,[    --enable-wrappers	enable tcp wrapper support], no)dnl

dnl SLAPD Backend options
OL_ARG_ENABLE(bdb2,[    --enable-bdb2	enable bdb2 backend], no)dnl
OL_ARG_WITH(bdb2_module,[      --with-bdb2-module	module type], static,
	[static dynamic])
OL_ARG_ENABLE(ldap,[    --enable-ldap	enable ldap backend], no)dnl
OL_ARG_WITH(ldap_module,[      --with-ldap-module	module type], static,
	[static dynamic])
OL_ARG_ENABLE(ldbm,[    --enable-ldbm	enable ldbm backend], yes)dnl
OL_ARG_WITH(ldbm_module,[      --with-ldbm-module	module type], static,
	[static dynamic])
OL_ARG_WITH(ldbm_api,[      --with-ldbm-api	use LDBM API], auto,
	[auto db2 db mdbm gdbm ndbm manual])
OL_ARG_WITH(ldbm_type,[      --with-ldbm-type	use LDBM type], auto,
	[auto btree hash])

OL_ARG_ENABLE(passwd,[    --enable-passwd	enable passwd backend], no)dnl
OL_ARG_WITH(passwd_module,[      --with-passwd-module	module type], static,
	[static dynamic])
OL_ARG_ENABLE(perl,[    --enable-perl	enable perl backend], no)dnl
OL_ARG_WITH(perl_module,[      --with-perl-module	module type], static,
	[static dynamic])
OL_ARG_ENABLE(shell,[    --enable-shell	enable shell backend], no)dnl
OL_ARG_WITH(shell_module,[      --with-shell-module	module type], static,
	[static dynamic])
OL_ARG_ENABLE(tcl,[    --enable-tcl	enable tcl backend], no)dnl
OL_ARG_WITH(tcl_module,[      --with-tcl-module	module type], static,
	[static dynamic])

dnl SLURPD OPTIONS
AC_ARG_WITH(xxslurpdoptions,[SLURPD Options:])
OL_ARG_ENABLE(slurpd,[  --enable-slurpd	enable building slurpd], auto)dnl

AC_ARG_WITH(xxliboptions,[Library Generation & Linking Options])
AM_ENABLE_STATIC
dnl AM_DISABLE_SHARED
AM_ENABLE_SHARED

dnl General "enable" options
# validate options
if test $ol_enable_dns = yes ; then
	if test $ol_enable_referrals = no ; then
		AC_MSG_ERROR([DNS requires --enable-referrals])
	fi
	if test $ol_enable_referrals = auto ; then
		AC_MSG_WARN([DNS requires referrals, adding --enable-referrals])
		ol_enable_referrals=yes
	fi
fi

if test $ol_enable_slapd = no ; then
	dnl SLAPD was specificallly disabled
	if test $ol_enable_bdb2 = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-bdb2 argument])
	fi
	if test $ol_enable_ldap = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-ldap argument])
	fi
	if test $ol_enable_ldbm = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-ldbm argument])
	fi
	if test $ol_enable_passwd = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-passwd argument])
	fi
	if test $ol_enable_perl = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-perl argument])
	fi
	if test $ol_enable_shell = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-shell argument])
	fi
	if test $ol_enable_tcl = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-tcl argument])
	fi
	if test $ol_enable_modules = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-modules argument])
	fi
	if test $ol_enable_wrappers = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-wrappers argument])
	fi
	if test $ol_enable_phonetic = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-phonetic argument])
	fi
	if test $ol_enable_rlookups = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-rlookups argument])
	fi
	if test $ol_with_ldbm_api != auto ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-ldbm-api argument])
	fi
	if test $ol_with_ldbm_type != auto ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-ldbm-type argument])
	fi
	if test $ol_with_bdb2_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-bdb2-module argument])
	fi
	if test $ol_with_ldap_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-ldap-module argument])
	fi
	if test $ol_with_ldbm_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-ldbm-module argument])
	fi
	if test $ol_with_passwd_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-passwd-module argument])
	fi
	if test $ol_with_perl_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-perl-module argument])
	fi
	if test $ol_with_shell_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-shell-module argument])
	fi
	if test $ol_with_tcl_module != static ; then
		AC_MSG_WARN([slapd disabled, ignoring --with-tcl-module argument])
	fi
	if test $ol_enable_slurpd = yes ; then
		AC_MSG_ERROR([slurpd requires slapd])
	fi

	# force settings to no
	ol_enable_bdb2=no
	ol_enable_ldap=no
	ol_enable_ldbm=no
	ol_enable_passwd=no
	ol_enable_perl=no
	ol_enable_shell=no
	ol_enable_tcl=no

	ol_enable_modules=no
	ol_enable_phonetic=no
	ol_enable_rlookups=no
	ol_enable_wrappers=no

	ol_with_ldbm_api=no
	ol_with_ldbm_type=no

	ol_with_bdb2_module=static
	ol_with_ldap_module=static
	ol_with_ldbm_module=static
	ol_with_passwd_module=static
	ol_with_perl_module=static
	ol_with_shell_module=static
	ol_with_tcl_module=static

	ol_enable_slurpd=no

elif test $ol_enable_ldbm = no ; then
	dnl SLAPD without LDBM

	if test $ol_with_ldbm_api != auto ; then
		AC_MSG_WARN([LDBM disabled, ignoring --with-ldbm-api argument])
	fi

	if test $ol_with_ldbm_type != auto ; then
		AC_MSG_WARN([LDBM disabled, ignoring --with-ldbm-type argument])
	fi

	if test $ol_with_ldbm_module != static ; then
		AC_MSG_WARN([LDBM disabled, ignoring --with-ldbm-module argument])
	fi

	if test $ol_enable_bdb2 = yes ; then
		AC_MSG_ERROR([BDB2 requires --enable-ldbm])
	fi

	if test $ol_enable_modules != yes -a \
		$ol_enable_ldap = no -a \
		$ol_enable_passwd = no -a \
		$ol_enable_perl = no -a \
		$ol_enable_shell = no -a \
		$ol_enable_tcl = no ; then
		AC_MSG_ERROR([slapd requires a backend])
	fi

	ol_with_ldbm_api=no
	ol_with_ldbm_type=no
	ol_with_ldbm_module=static

elif test $ol_enable_bdb2 = yes ; then
	dnl SLAPD with BDB2

	if test $ol_with_ldbm_api != auto -a \
		$ol_with_ldbm_api != db2 ; then
		AC_MSG_ERROR([BDB2 requires LDBM API DB2])
	fi

	ol_with_ldbm_api=db2

else
	dnl SLAPD with LDBM

	if test $ol_enable_bdb2 != no ; then
		if test $ol_with_ldbm_api != auto -a \
			$ol_with_ldbm_api != db2 ; then
			AC_MSG_WARN([BDB2 requires LDBM api db2 or auto])
			ol_enable_bdb2=no
		fi
	fi

	if test $ol_with_ldbm_api = gdbm -a \
		$ol_with_ldbm_type = btree ; then
		AC_MSG_ERROR([GDBM only supports LDBM type hash])
	fi
	if test $ol_with_ldbm_api = mdbm -a \
		$ol_with_ldbm_type = btree ; then
		AC_MSG_ERROR([MDBM only supports LDBM type hash])
	fi
	if test $ol_with_ldbm_api = ndbm -a \
		$ol_with_ldbm_type = btree ; then
		AC_MSG_ERROR([NDBM only supports LDBM type hash])
	fi
fi

if test $ol_enable_slurpd = yes ; then
	dnl SLURPD was specifically enabled
	if test $ol_with_threads = no ; then
		AC_MSG_ERROR([slurpd requires threads])
	fi
fi

AC_MSG_RESULT(done)

## Initialize vars
LDAP_LIBS=
LDBM_LIBS=
LTHREAD_LIBS=
LUTIL_LIBS=

LDAPD_LIBS=
SLAPD_LIBS=
SLURPD_LIBS=

BUILD_LDAPD=no
BUILD_SLAPD=no
BUILD_SLURPD=no

BUILD_BDB2=no
BUILD_LDAP=no
BUILD_LDBM=no
BUILD_PASSWD=no
BUILD_PERL=no
BUILD_SHELL=no
BUILD_TCL=no
BUILD_THREAD=no

BUILD_BDB2_DYNAMIC=no
BUILD_LDAP_DYNAMIC=no
BUILD_LDBM_DYNAMIC=no
BUILD_PASSWD_DYNAMIC=no
BUILD_PERL_DYNAMIC=no
BUILD_SHELL_DYNAMIC=no
BUILD_TCL_DYNAMIC=no

SLAPD_MODULES_LDFLAGS=
SLAPD_MODULES_CPPFLAGS=

SLAPD_PERL_LDFLAGS=
SLAPD_PERL_CPPFLAGS=

KRB_LIBS=
READLINE_LIBS=
TERMCAP_LIBS=
TLS_LIBS=

dnl ----------------------------------------------------------------
dnl Checks for programs

dnl AC_PROG_INSTALL

dnl AIX Thread requires we use cc_r or xlc_r.
dnl But only do this IF AIX and CC is not set
dnl and threads are auto|yes|posix.
dnl
dnl If we find cc_r|xlc_r, force pthreads and assume
dnl		pthread_create is in $LIBS (ie: don't bring in
dnl		any additional thread libraries)
dnl If we do not find cc_r|xlc_r, disable threads

ol_aix_threads=no
case "$target" in
*-*-aix*) dnl all AIX is not a good idea.
	if test -z "CC" ; then
		case "$ol_with_threads" in
		auto | yes |  posix) ol_aix_threads=yes ;;
		esac
	fi
;;
esac

if test $ol_aix_threads = yes ; then
	if test -z "${CC}" ; then
		AC_CHECK_PROGS(CC,cc_r xlc_r cc)

		if test "$CC" = cc ; then
			dnl no CC! don't allow --with-threads
			if test $ol_with_threads != auto ; then
				AC_MSG_ERROR([--with-threads requires cc_r (or other suitable compiler) on AIX])
			else
				AC_MSG_WARN([disabling threads, no cc_r on AIX])
			fi
			ol_with_threads=no
  		fi
	fi

	if test "${CC}" = "cc_r" -o "${CC}" = "xlc_r" ; then
		ol_with_threads=posix
		ol_cv_pthread_create=yes
	fi
fi

if test -z "${CC}"; then
	AC_CHECK_PROGS(CC,cc)
fi

dnl The default CFLAGS is empty NOT whatever AC_PROG_CC sets.
dnl (for now, let autoconf sort this out)
dnl CFLAGS=${CFLAGS-""}

AM_PROG_LIBTOOL
dnl AC_PROG_MAKE_SET

AC_PROG_AWK
OL_PROG_LN_H
AC_PROG_LN_S

if test "$LN_H" = "cp" -a "$LN_S" = "ln"; then
	LN_S="$LN_H"
fi

AC_PATH_PROG(SENDMAIL, sendmail, /usr/lib/sendmail,
	$PATH:/usr/libexec:/usr/lib:/usr/sbin:/usr/etc:/etc)
AC_PATH_PROG(EDITOR, vi, /usr/ucb/vi, $PATH:/usr/ucb)
AC_PATH_PROG(FINGER, finger, /usr/ucb/finger, $PATH:/usr/ucb)

ol_link_modules=no
if test $ol_enable_modules != no ; then
	AC_PATH_PROG(GLIBCONFIG, glib-config)

	if test "no$GLIBCONFIG" = "no" ; then
		if test $ol_enable_modules = yes ; then
			AC_MSG_ERROR([could not locate glib-config])
		fi

	else
		SLAPD_MODULES_VERSION="`$GLIBCONFIG --version gmodule`"
		SLAPD_MODULES_CPPFLAGS="`$GLIBCONFIG --cflags gmodule`"
		SLAPD_MODULES_LDFLAGS="`$GLIBCONFIG --libs gmodule`"

		dnl should check glib version
		ol_link_modules=yes
	fi
else
	ol_with_bdb2_module=static
	ol_with_ldap_module=static
	ol_with_ldbm_module=static
	ol_with_passwd_module=static
	ol_with_perl_module=static
	ol_with_shell_module=static
	ol_with_tcl_module=static
fi

ol_link_perl=no
if test $ol_enable_perl != no ; then
	AC_PATH_PROG(PERLBIN, perl, /usr/bin/perl)

	if test "no$PERLBIN" = "no" ; then
		if test $ol_enable_perl = yes ; then
			AC_MSG_ERROR([could not locate perl])
		fi

	else
		SLAPD_PERL_LDFLAGS="`$PERLBIN -MExtUtils::Embed -e ldopts|sed -e s/-lc//`"
		SLAPD_PERL_CPPFLAGS="`$PERLBIN -MExtUtils::Embed -e ccopts`"

		dnl should check perl version
		ol_link_perl=yes
	fi
fi

AC_PROG_CPP

if test $cross_compiling = yes -a $ol_enable_x_compile = yes; then
	AC_MSG_WARN([cross compiling....  some functionality will be removed.])

elif test $cross_compiling = no -a $ol_enable_x_compile = yes; then
	AC_MSG_WARN([programs compiled here do run here...])
	AC_MSG_ERROR([  if not cross compiling, use --disable-x-compile.])

elif test $cross_compiling = yes -a $ol_enable_x_compile = no; then
	AC_MSG_WARN([programs compiled here do not run here...])
	AC_MSG_ERROR([  if cross compiling,  add --enable-x-compile.])
fi

dnl Checks for UNIX Variants
AC_AIX
AC_ISC_POSIX
AC_MINIX

dnl BeOS requires -lbe -lroot -lnet
AC_CHECK_LIB(be, be_app, [LIBS="$LIBS -lbe -lroot -lnet"], :, [-lroot -lnet])

dnl Checks for system services
AC_CYGWIN
AC_MINGW32
AC_EXEEXT
AC_OBJEXT

AC_DEFINE_UNQUOTED( EXEEXT, "${EXEEXT}", [defined to be the EXE extension])

dnl OpenLDAP requires STDC features
AM_PROG_CC_STDC
if test "X${am_cv_prog_cc_stdc}" = "Xno" ; then
	AC_MSG_ERROR([OpenLDAP requires compiler to support STDC constructs.])
fi

dnl AM_C_PROTOTYPES

dnl Check cc depend flags
OL_MKDEPEND
if test "${ol_cv_mkdep}" = no ; then
	# this will soon become an error
	AC_MSG_WARN([do not know how to generate dependencies])
fi

dnl Checks for libraries

dnl Find socket()
dnl Likely combinations:
dnl		-lsocket [ -lnsl_s | -lnsl ]
dnl		-linet

AC_CHECK_FUNC(socket, :, [	
dnl
dnl hopefully we won't include too many libraries
dnl
	AC_CHECK_LIB(socket, main)
	AC_CHECK_LIB(net, main)
	AC_CHECK_LIB(net, socket)
	AC_CHECK_LIB(nsl_s, main)
	AC_CHECK_LIB(nsl, main)
	AC_CHECK_LIB(inet, socket)
	AC_CHECK_LIB(gen, main)
])

dnl Check for resolver routines
AC_CHECK_FUNCS(res_search)
if test $ac_cv_func_res_search = "no" ; then 
	AC_CHECK_LIB(bind, res_search)
	if test "$ac_cv_lib_bind_res_search" = "yes" ; then
		AC_DEFINE(HAVE_RES_SEARCH,1)
	else
		AC_CHECK_LIB(resolv, res_search)
		if test "$ac_cv_lib_resolv_res_search" = "yes" ; then
			AC_DEFINE(HAVE_RES_SEARCH,1)
		fi
	fi
fi

dnl HP-UX requires -lV3
AC_CHECK_LIB(V3, sigset)

AC_CHECK_HEADERS( regex.h )
if test "$ac_cv_header_regex_h" != yes ; then
	AC_MSG_ERROR([POSIX regex.h required.])
fi
AC_CHECK_FUNC(regfree, :, AC_MSG_ERROR([POSIX regex required.]))

OL_POSIX_REGEX
if test "$ol_cv_c_posix_regex" = no ; then
	AC_MSG_ERROR([broken POSIX regex!])
fi

AC_CHECK_FUNC(select, :, AC_MSG_ERROR([select() required.]))

dnl Select arg types
dnl (if this detection becomes permenent, it and the select() detection
dnl should be done before the yielding select test) 
AC_FUNC_SELECT_ARGTYPES

# ISODE tests
ol_link_isode=no
if test $ol_enable_ldapd != no ; then
	AC_MSG_WARN([ldapd is not supported and may suffer from bit rot.])

	dnl look for ISODE libraries
	AC_CHECK_LIB(xtpp, main, [
		ol_link_isode=yes
		AC_DEFINE(HAVE_XTPP,1, [define if you have -lxttp])
		LDAPD_LIBS="$LDAPD_LIBS -lxtpp -lxtdsap -lxtisode -losi"
		],:,[-lxtdsap -lxtisode -losi])
	AC_CHECK_LIB(dsap, main, [
		ol_link_isode=yes
		AC_DEFINE(HAVE_DSAP,1, [define if you have -ldsap])
		LDAPD_LIBS="$LDAPD_LIBS -ldsap"
		],:,[-lisode])
	AC_CHECK_LIB(isode, main, [
		ol_link_isode=yes
		AC_DEFINE(HAVE_ISODE,1, [define if you have -lisode])
		LDAPD_LIBS="$LDAPD_LIBS -lisode"
		],:)
fi

if test $ol_link_isode != no; then
	AC_CHECK_LIB(pp, main, [
		AC_DEFINE(HAVE_PP,1, [define if you have -lpp])
		LDAPD_LIBS="-lpp $LDAPD_LIBS"
		],:)

	AC_PATH_PROG(PEPSY, pepsy)
fi

dnl
dnl check for kerberos
dnl
ol_link_kerberos=no

if test $ol_with_kerberos = auto -o $ol_with_kerberos = k5 ; then
	AC_CHECK_HEADERS(kerberosIV/krb.h kerberosIV/des.h)

	if test $ac_cv_header_kerberosIV_krb_h = yes ; then
		AC_CHECK_LIB(krb4, main, [have_k5=yes], [have_k5=no],
			[-lkrb5 -ldes425])

		if test $have_k5 = yes ; then
			ol_with_kerberos=found
			ol_link_kerberos=yes

			KRB_LIBS="-lkrb4 -lkrb5 -ldes425"

			LIBS="$KRB_LIBS $LIBS"

			AC_CACHE_CHECK([for des_debug in Kerberos libraries],
				[ol_cv_var_des_debug], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="$KRB_LIBS $LIBS"
				AC_TRY_LINK([
#include <kerberosIV/krb.h>
#include <kerberosIV/des.h>
extern int des_debug;
],[
des_debug = 1;
],				ol_cv_var_des_debug=yes, ol_cv_var_des_debug=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_var_des_debug = yes ; then
				AC_DEFINE(HAVE_DES_DEBUG,1,
					[define if you have Kerberos des_debug])
			fi

			LIBS="$save_LIBS"
		fi
	fi
fi

if test $ol_with_kerberos = auto -o $ol_with_kerberos = k4 ; then
	AC_CHECK_HEADERS(krb.h des.h)

	if test $ac_cv_header_krb_h = yes ; then
		AC_CHECK_LIB(krb, main, [have_k4=yes], [have_k4=no], [-ldes])

		if test $have_k4 = yes ; then
			ol_with_kerberos=found
			ol_link_kerberos=yes

			KRB_LIBS="-lkrb -ldes"
		fi
	fi
fi

if test $ol_link_kerberos = yes ; then
	AC_DEFINE(HAVE_KERBEROS, 1, [define if you have Kerberos])
fi

dnl
dnl Check for SSL/TLS
dnl
ol_link_tls=no
if test $ol_with_tls != no ; then
	
	AC_CHECK_HEADERS(ssl.h)
	
	if test $ac_cv_header_ssl_h = yes ; then
		AC_CHECK_LIB(ssl, SSLeay_add_ssl_algorithms, 
			[have_ssleay=yes
			need_rsaref=no],
			[have_ssleay=no],
			[-lcrypto])
			
		if test $have_ssleay = no ; then
			AC_CHECK_LIB(ssl, ssl3_accept, 
				[have_ssleay=yes
				need_rsaref=yes], [have_ssleay=no],
				[-lcrypto -lRSAglue -lrsaref])
		fi

		if test $have_ssleay = yes ; then
			ol_with_tls=found
			ol_link_tls=yes

			AC_DEFINE(HAVE_SSLEAY, 1, 
				[define if you have SSLeay or OpenSSL])

			if test $need_rsaref = yes; then
				AC_DEFINE(HAVE_RSAREF, 1, 
					[define if you have RSAref])

				TLS_LIBS="-lssl -lcrypto -lRSAglue -lrsaref"
			else
				TLS_LIBS="-lssl -lcrypto"
			fi
		fi
	fi
fi

if test $ol_link_tls = yes ; then
	AC_DEFINE(HAVE_TLS, 1, [define if you have TLS])
fi	

dnl Tests for reentrant functions necessary to build a
dnl thread_safe -lldap.
AC_CHECK_FUNCS(		\
	ctime_r			\
	gethostbyname_r	gethostbyaddr_r \
)

if test "$ac_cv_func_ctime_r" = no ; then
	ol_cv_func_ctime_r_nargs=0
else
	OL_FUNC_CTIME_R_NARGS
dnl	OL_FUNC_CTIME_R_TYPE
fi

if test "$ac_cv_func_gethostbyname_r" = yes ; then
 	OL_FUNC_GETHOSTBYNAME_R_NARGS
else
 	ol_cv_func_gethostbyname_r_nargs=0
fi
 
if test "$ac_cv_func_gethostbyaddr_r" = yes ; then
 	OL_FUNC_GETHOSTBYADDR_R_NARGS
else
 	ol_cv_func_gethostbyaddr_r_nargs=0
fi

if test "$ac_cv_func_ctime_r" = yes \
	-a "$ol_cv_func_ctime_r_nargs" -ge 2 \
	-a "$ol_cv_func_ctime_r_nargs" -le 3 \
	-a "$ac_cv_func_gethostbyname_r" = yes \
	-a "$ol_cv_func_gethostbyname_r_nargs" -ge 5 \
	-a "$ol_cv_func_gethostbyname_r_nargs" -le 6 \
 	-a "$ac_cv_func_gethostbyaddr_r" = yes \
 	-a "$ol_cv_func_gethostbyaddr_r_nargs" -ge 5 \
	-a "$ol_cv_func_gethostbyaddr_r_nargs" -le 6 \
 	; then
 
 	AC_DEFINE(LDAP_API_FEATURE_X_OPENLDAP_REENTRANT,1)
fi

ol_link_threads=no
if test $ol_with_threads = auto -o $ol_with_threads = yes \
	-o $ol_with_threads = posix ; then

	AC_CHECK_HEADERS(pthread.h sched.h)

	if test $ac_cv_header_pthread_h = yes ; then
		OL_POSIX_THREAD_VERSION

		if test $ol_cv_pthread_version = final ; then
			AC_DEFINE(HAVE_PTHREADS_FINAL,1,
				[define if pthreads API compatible with final spec])
		elif test $ol_cv_pthread_version = draft4 ; then
			AC_DEFINE(HAVE_PTHREADS_D4,1,
				[define if pthreads API compatible with draft4 spec])
		else
			AC_MSG_ERROR([unknown pthread version])
		fi

		# consider threads found
		ol_with_threads=found

		OL_HEADER_LINUX_THREADS

		dnl Now the hard part, how to link?
		dnl
		dnl currently supported checks:
		dnl
		dnl Check for no flags 
		dnl 	pthread_create() in $LIBS
		dnl
		dnl Check special pthread (final) flags
		dnl 	pthread_create() with -mt (Solaris)
		dnl 	pthread_create() with -kthread (FreeBSD)
		dnl 	pthread_create() with -pthread (FreeBSD/Digital Unix)
		dnl 	pthread_create() with -pthreads (?)
		dnl 	pthread_create() with -thread (?)
		dnl
		dnl Check pthread (final) libraries
		dnl 	pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1)
		dnl 	pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1)
		dnl 	(skipped) pthread_mutex_trylock() in -lpthread -lexc (OSF/1)
		dnl 	pthread_join() -Wl,-woff,85 -lpthread (IRIX)
		dnl 	pthread_create() in -lpthread (many)
		dnl 	pthread_create() in -lc_r (FreeBSD)
		dnl
		dnl Check pthread (draft4) flags (depreciated)
		dnl 	pthread_create() with -threads (OSF/1)
		dnl
		dnl Check pthread (draft4) libraries (depreciated)
		dnl 	pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1)
		dnl 	pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1)
		dnl 	pthread_mutex_trylock() in -lpthreads -lexc (OSF/1)
		dnl 	pthread_create() in -lpthreads (many)
		dnl

		dnl pthread_create in $LIBS
		AC_MSG_CHECKING([for pthread_create in default libraries])
		AC_CACHE_VAL(ol_cv_pthread_create,[
		AC_TRY_RUN([
#include <pthread.h>
#ifndef NULL
#define NULL (void*)0
#endif

static void *task(p)
	void *p;
{
	return (void *) (p == NULL);
}

int main(argc, argv)
	int argc;
	char **argv;
{
	pthread_t t;
	int status;

	/* make sure pthread_create() isn't just a stub */
#if HAVE_PTHREADS_D4
	status = pthread_create(&t, pthread_attr_default, task, NULL);
#else
	status = pthread_create(&t, NULL, task, NULL);
#endif

	if( status ) return status;

	/* make sure pthread_detach() isn't just a stub */
#if HAVE_PTHREADS_D4
	status = pthread_detach( &t );
#else
	status = pthread_detach( t );
#endif

	if( status ) return status;

	return status;
}
],
			[ol_cv_pthread_create=yes],
			[ol_cv_pthread_create=no],
			[dnl assume yes
			ol_cv_pthread_create=yes])])
		AC_MSG_RESULT($ol_cv_pthread_create)

		if test $ol_cv_pthread_create != no ; then
			ol_link_threads=posix
			ol_link_pthreads=""
		fi
		
		OL_PTHREAD_TRY_LINK([-mt],		[ol_cv_pthread_mt])
		OL_PTHREAD_TRY_LINK([-kthread],	[ol_cv_pthread_kthread])
		OL_PTHREAD_TRY_LINK([-pthread],	[ol_cv_pthread_pthread])
		OL_PTHREAD_TRY_LINK([-pthreads],[ol_cv_pthread_pthreads])
		OL_PTHREAD_TRY_LINK([-thread],	[ol_cv_pthread_thread])

		OL_PTHREAD_TRY_LINK([-lpthread -lmach -lexc -lc_r],
			[ol_cv_pthread_lpthread_lmach_lexc_lc_r])
		OL_PTHREAD_TRY_LINK([-lpthread -lmach -lexc],
			[ol_cv_pthread_lpthread_lmach_lexc])
dnl		OL_PTHREAD_TRY_LINK([-lpthread -lexc],
dnl			[ol_cv_pthread_lpthread_lexc])

		OL_PTHREAD_TRY_LINK([-lpthread -Wl,-woff,85],
			[ol_cv_pthread_lib_lpthread_woff])

		OL_PTHREAD_TRY_LINK([-lpthread],[ol_cv_pthread_lpthread])
		OL_PTHREAD_TRY_LINK([-lc_r],	[ol_cv_pthread_lc_r])

		OL_PTHREAD_TRY_LINK([-threads],	[ol_cv_pthread_threads])

		OL_PTHREAD_TRY_LINK([-lpthreads -lmach -lexc -lc_r],
			[ol_cv_pthread_lpthreads_lmach_lexc_lc_r])
		OL_PTHREAD_TRY_LINK([-lpthreads -lmach -lexc],
			[ol_cv_pthread_lpthreads_lmach_lexc])
		OL_PTHREAD_TRY_LINK([-lpthreads -lexc],
			[ol_cv_pthread_lpthreads_lexc])

		OL_PTHREAD_TRY_LINK([-lpthreads],	[ol_cv_pthread_lib_lpthreads])

		if test $ol_link_threads != no ; then
			AC_DEFINE(HAVE_PTHREADS,1,
				[define if you have POSIX Threads])

			LTHREAD_LIBS="$LTHREAD_LIBS $ol_link_pthreads"

			dnl save flags
			save_CPPFLAGS="$CPPFLAGS"
			save_LIBS="$LIBS"
			LIBS="$LTHREAD_LIBS $LIBS"

			dnl All POSIX Thread (final) implementations should have
			dnl sched_yield instead of pthread yield.
			dnl check for both
			AC_CHECK_FUNCS(sched_yield pthread_yield)

			if test $ac_cv_func_sched_yield = no -a \
				$ac_cv_func_pthread_yield = no ; then
				dnl Digital UNIX has sched_yield() in -lrt
				AC_CHECK_LIB(rt, sched_yield,
					[LTHREAD_LIBS="$LTHREAD_LIBS -lrt"
					AC_DEFINE(HAVE_SCHED_YIELD,1)
					ac_cv_func_sched_yield=yes],
					[ac_cv_func_sched_yield=no])
			fi
			if test $ac_cv_func_sched_yield = no -a \
				$ac_cv_func_pthread_yield = no ; then
				dnl Solaris has sched_yield() stub in -lposix4
				dnl but we'll use thr_yield instead.
				AC_CHECK_FUNCS(thr_yield)
			fi
			if test $ac_cv_func_sched_yield = no -a \
				$ac_cv_func_pthread_yield = no -a \
				"$ac_cv_func_thr_yield" = no ; then
				AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])
			fi

			dnl Check functions for compatibility
			AC_CHECK_FUNCS(pthread_kill)

			dnl Check for pthread_detach with <pthread.h> inclusion
			dnl as it's symbol may have been mangled.
			AC_CACHE_CHECK([for pthread_detach with <pthread.h>],
				[ol_cv_func_pthread_detach], [
				dnl save the flags
				AC_TRY_LINK([
#include <pthread.h>
#ifndef NULL
#define NULL (void*)0
#endif
],
					[pthread_detach(NULL);],
					[ol_cv_func_pthread_detach=yes],
					[ol_cv_func_pthread_detach=no])
			])

			if test $ol_cv_func_pthread_detach = no ; then
				AC_MSG_ERROR([could not locate pthread_detach()])
			fi

			AC_DEFINE(HAVE_PTHREAD_DETACH,1,
				[define if you have pthread_detach function])

			dnl Check for setconcurreny functions
			AC_CHECK_FUNCS(	\
				pthread_setconcurrency \
				pthread_getconcurrency \
				thr_setconcurrency \
				thr_getconcurrency \
			)

			OL_SYS_LINUX_THREADS
			OL_LINUX_THREADS

			if test $ol_cv_linux_threads = error; then
				AC_MSG_ERROR([LinuxThreads header/library mismatch]);
			fi

			AC_MSG_CHECKING([if pthread_create() works])
			AC_CACHE_VAL(ol_cv_pthread_create_works,[
			AC_TRY_RUN([
#include <pthread.h>
#ifndef NULL
#define NULL (void*)0
#endif

static void *task(p)
	void *p;
{
	return (void *) (p == NULL);
}

int main(argc, argv)
	int argc;
	char **argv;
{
	pthread_t t;
#if HAVE_PTHREADS_D4
	exit(pthread_create(&t, pthread_attr_default, task, NULL));
#else
	exit(pthread_create(&t, NULL, task, NULL));