File configure.in of Package libnldapx

dnl $OpenLDAP: pkg/ldap/configure.in,v 1.631.2.9 2008/02/11 23:26:37 kurt Exp $
dnl This work is part of OpenLDAP Software <http://www.openldap.org/>.
dnl
dnl Copyright 1998-2008 The OpenLDAP Foundation.
dnl All rights reserved.
dnl
dnl Redistribution and use in source and binary forms, with or without
dnl modification, are permitted only as authorized by the OpenLDAP
dnl Public License.
dnl
dnl A copy of this license is available in the file LICENSE in the
dnl top-level directory of the distribution or, alternatively, at
dnl <http://www.OpenLDAP.org/license.html>.
dnl
dnl ----------------------------------------------------------------
dnl Disable config.cache!
define([AC_CACHE_LOAD], )dnl
define([AC_CACHE_SAVE], )dnl
dnl ----------------------------------------------------------------
dnl Disable libtool 1.5 support for languages we don't use
define([AC_LIBTOOL_LANG_CXX_CONFIG], [:])dnl
define([AC_LIBTOOL_LANG_F77_CONFIG], [:])dnl
define([AC_LIBTOOL_LANG_GCJ_CONFIG], [:])dnl
dnl ================================================================
dnl Configure.in for OpenLDAP
AC_COPYRIGHT([[Copyright 1998-2008 The OpenLDAP Foundation. All rights reserved.
Restrictions apply, see COPYRIGHT and LICENSE files.]])
AC_REVISION([$OpenLDAP: pkg/ldap/configure.in,v 1.631.2.9 2008/02/11 23:26:37 kurt Exp $])
AC_INIT([OpenLDAP],,[http://www.openldap.org/its/])
m4_define([AC_PACKAGE_BUGREPORT],[<http://www.openldap.org/its/>])
AC_CONFIG_SRCDIR(build/version.sh)dnl
dnl ----------------------------------------------------------------
dnl OpenLDAP Autoconf Macros
builtin(include, build/openldap.m4)dnl
dnl ================================================================

AC_CONFIG_AUX_DIR(build)dnl

eval `$ac_aux_dir/version.sh`
if test -z "$OL_STRING"; then
	AC_MSG_ERROR([could not determine version])
fi

if test -f "$ac_aux_dir/shtool" && test ! -d $ac_aux_dir/shtool; then
	ac_cv_shtool="$ac_aux_dir/shtool"
else
	AC_MSG_ERROR([no shtool found in $ac_aux_dir])
fi

SHTOOL="$ac_cv_shtool"
dnl AC_SUBST(SHTOOL)dnl

TB="" TN=""
if test -t 1; then
	TB="`$SHTOOL echo -e '%B' 2>/dev/null`"
	TN="`$SHTOOL echo -e '%b' 2>/dev/null`"
fi

OPENLDAP_CVS=""
if test -d $ac_aux_dir/CVS; then
	OPENLDAP_CVS="(from CVS sources) "
fi

echo "Configuring ${TB}${OL_STRING}${TN} ${OPENLDAP_CVS}..."

dnl Determine host platform
dnl		we try not to use this for much
AC_CANONICAL_TARGET([])

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

AC_DEFINE_UNQUOTED(LDAP_VENDOR_VERSION,$OL_API_INC,Version)
AC_DEFINE_UNQUOTED(LDAP_VENDOR_VERSION_MAJOR,$OL_MAJOR,Major)
AC_DEFINE_UNQUOTED(LDAP_VENDOR_VERSION_MINOR,$OL_MINOR,Minor)
AC_DEFINE_UNQUOTED(LDAP_VENDOR_VERSION_PATCH,$OL_PATCH,Patch)

OPENLDAP_LIBRELEASE=$OL_API_LIB_RELEASE
AC_SUBST(OPENLDAP_LIBRELEASE)dnl

OPENLDAP_LIBVERSION=$OL_API_LIB_VERSION
AC_SUBST(OPENLDAP_LIBVERSION)dnl

OPENLDAP_RELEASE_DATE="$OL_RELEASE_DATE"
AC_SUBST(OPENLDAP_RELEASE_DATE)dnl

dnl We use autoconf features new to 2.59.  Later versions like won't work.
dnl aclocal.m4 should be built using aclocal from automake 1.5
dnl libtool 1.5 should be installed.
AC_PREREQ(2.59)dnl Required Autoconf version

AH_TOP([
/* begin of portable.h.pre */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 *
 * Copyright 1998-2008 The OpenLDAP Foundation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted only as authorized by the OpenLDAP
 * Public License.
 *
 * A copy of this license is available in the file LICENSE in the
 * top-level directory of the distribution or, alternatively, at
 * <http://www.OpenLDAP.org/license.html>.
 */

#ifndef _LDAP_PORTABLE_H
#define _LDAP_PORTABLE_H

/* define this if needed to get reentrant functions */
#ifndef REENTRANT
#undef REENTRANT
#endif
#ifndef _REENTRANT
#undef _REENTRANT
#endif

/* define this if needed to get threadsafe functions */
#ifndef THREADSAFE
#undef THREADSAFE
#endif
#ifndef _THREADSAFE
#undef _THREADSAFE
#endif
#ifndef THREAD_SAFE
#undef THREAD_SAFE
#endif
#ifndef _THREAD_SAFE
#undef _THREAD_SAFE
#endif

#ifndef _SGI_MP_SOURCE
#undef _SGI_MP_SOURCE
#endif

/* end of portable.h.pre */
])
AH_BOTTOM([
/* begin of portable.h.post */

#ifdef _WIN32
	/* don't suck in all of the win32 api */
#	define WIN32_LEAN_AND_MEAN 1
#endif

#ifndef LDAP_NEEDS_PROTOTYPES
/* force LDAP_P to always include prototypes */
#define LDAP_NEEDS_PROTOTYPES 1
#endif

#ifndef LDAP_REL_ENG
#if (LDAP_VENDOR_VERSION == 000000) && !defined(LDAP_DEVEL)
#define LDAP_DEVEL
#endif
#if defined(LDAP_DEVEL) && !defined(LDAP_TEST)
#define LDAP_TEST
#endif
#endif

#ifdef HAVE_STDDEF_H
#	include <stddef.h>
#endif

#ifdef HAVE_EBCDIC 
/* ASCII/EBCDIC converting replacements for stdio funcs
 * vsnprintf and snprintf are used too, but they are already
 * checked by the configure script
 */
#define fputs ber_pvt_fputs
#define fgets ber_pvt_fgets
#define printf ber_pvt_printf
#define fprintf ber_pvt_fprintf
#define vfprintf ber_pvt_vfprintf
#define vsprintf ber_pvt_vsprintf
#endif

#include "ac/fdset.h"

#include "ldap_cdefs.h"
#include "ldap_features.h"

#include "ac/assert.h"
#include "ac/localize.h"

#endif /* _LDAP_PORTABLE_H */
/* end of portable.h.post */
])

AC_CONFIG_HEADERS([include/portable.h include/ldap_features.h include/lber_types.h])

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

top_builddir=`pwd`
AC_SUBST(top_builddir)dnl

dnl ----------------------------------------------------------------
dnl --with-subdir
ldap_subdir="/openldap"

AC_ARG_WITH(subdir,
[  --with-subdir=DIR       change default subdirectory used for installs],
[case "$withval" in
	no) ldap_subdir=""
		;;
	yes)
		;;
	/*|\\*)
		ldap_subdir="$withval"
		;;
	*)
		ldap_subdir="/$withval"
		;;
esac
])dnl

AC_SUBST(ldap_subdir)dnl

dnl ----------------------------------------------------------------
dnl General "enable" options
dnl set default to traditional to enable the original debug style
OL_ARG_ENABLE(debug,[  --enable-debug 	  enable debugging], yes, [no yes traditional])dnl
OL_ARG_ENABLE(dynamic,[  --enable-dynamic	  enable linking built binaries with dynamic libs], no)dnl
OL_ARG_ENABLE(syslog,[  --enable-syslog	  enable syslog support], auto)dnl
OL_ARG_ENABLE(proctitle,[  --enable-proctitle	  enable proctitle support], yes)dnl
dnl OL_ARG_ENABLE(referrals,[  --enable-referrals	  enable LDAPv2+ Referrals (experimental)], no)dnl
ol_enable_referrals=${ol_enable_referrals-no}
OL_ARG_ENABLE(ipv6,[  --enable-ipv6 	  enable IPv6 support], auto)dnl
OL_ARG_ENABLE(local,[  --enable-local	  enable AF_LOCAL (AF_UNIX) socket support], auto)dnl

dnl ----------------------------------------------------------------
dnl General "with" options
OL_ARG_WITH(cyrus_sasl,[  --with-cyrus-sasl	  with Cyrus SASL support],
	auto, [auto yes no] )
OL_ARG_WITH(fetch,[  --with-fetch		  with fetch(3) URL support],
	auto, [auto yes no] )
OL_ARG_WITH(threads,[  --with-threads	  with threads],
	auto, [auto nt posix mach pth lwp yes no manual] )
OL_ARG_WITH(tls,[  --with-tls		  with TLS/SSL support auto|openssl|gnutls],
	auto, [auto openssl gnutls yes no] )
OL_ARG_WITH(yielding_select,
	[  --with-yielding-select  with implicitly yielding select],
	auto, [auto yes no manual] )
OL_ARG_WITH(mp,
	[  --with-mp               with multiple precision statistics auto|longlong|long|bignum|gmp],
	auto, [auto longlong long bignum gmp yes no])
OL_ARG_WITH(odbc,
	[  --with-odbc             with specific ODBC support iodbc|unixodbc|auto],
	auto, [auto iodbc unixodbc] )

dnl ----------------------------------------------------------------
dnl Server options
dnl ----------------------------------------------------------------

dnl ----------------------------------------------------------------
dnl SLAPD OPTIONS
AC_ARG_ENABLE(xxslapdoptions,[
SLAPD (Standalone LDAP Daemon) Options:])
OL_ARG_ENABLE(slapd,[  --enable-slapd	  enable building slapd], yes)dnl
OL_ARG_ENABLE(dynacl,[    --enable-dynacl	  enable run-time loadable ACL support (experimental)], no)dnl
OL_ARG_ENABLE(aci,[    --enable-aci	  enable per-object ACIs (experimental)], no, [no yes mod])dnl
OL_ARG_ENABLE(cleartext,[    --enable-cleartext	  enable cleartext passwords], yes)dnl
OL_ARG_ENABLE(crypt,[    --enable-crypt	  enable crypt(3) passwords], no)dnl
OL_ARG_ENABLE(lmpasswd,[    --enable-lmpasswd	  enable LAN Manager passwords], no)dnl
OL_ARG_ENABLE(spasswd,[    --enable-spasswd	  enable (Cyrus) SASL password verification], no)dnl
OL_ARG_ENABLE(modules,[    --enable-modules	  enable dynamic module support], no)dnl
OL_ARG_ENABLE(rewrite,[    --enable-rewrite	  enable DN rewriting in back-ldap and rwm overlay], auto)dnl
OL_ARG_ENABLE(rlookups,[    --enable-rlookups	  enable reverse lookups of client hostnames], no)dnl
OL_ARG_ENABLE(slapi,[    --enable-slapi        enable SLAPI support (experimental)], no)dnl
OL_ARG_ENABLE(slp,[    --enable-slp          enable SLPv2 support], no)dnl     
OL_ARG_ENABLE(wrappers,[    --enable-wrappers	  enable tcp wrapper support], no)dnl

dnl ----------------------------------------------------------------
dnl SLAPD Backend Options
Backends="bdb \
	dnssrv \
	hdb \
	ldap \
	meta \
	monitor \
	null \
	passwd \
	perl \
	relay \
	shell \
	sock \
	sql"

AC_ARG_ENABLE(xxslapbackends,[
SLAPD Backend Options:])

OL_ARG_ENABLE(backends,[    --enable-backends	  enable all available backends],
	--, [no yes mod])dnl
OL_ARG_ENABLE(bdb,[    --enable-bdb	  enable Berkeley DB backend],
	yes, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(dnssrv,[    --enable-dnssrv	  enable dnssrv backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(hdb,[    --enable-hdb	  enable Hierarchical DB backend],
	yes, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(ldap,[    --enable-ldap	  enable ldap backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(meta,[    --enable-meta	  enable metadirectory backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(monitor,[    --enable-monitor	  enable monitor backend],
	yes, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(null,[    --enable-null	  enable null backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(passwd,[    --enable-passwd	  enable passwd backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(perl,[    --enable-perl	  enable perl backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(relay,[    --enable-relay  	  enable relay backend],
	yes, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(shell,[    --enable-shell	  enable shell backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(sock,[    --enable-sock	  enable sock backend],
	no, [no yes mod], ol_enable_backends)dnl
OL_ARG_ENABLE(sql,[    --enable-sql	  enable sql backend],
	no, [no yes mod], ol_enable_backends)dnl

dnl ----------------------------------------------------------------
dnl SLAPD Overlay Options
Overlays="accesslog \
	auditlog \
	constraint \
	dds \
	dyngroup \
	dynlist \
	memberof \
	ppolicy \
	proxycache \
	refint \
	retcode \
	rwm \
	seqmod \
	syncprov \
	translucent \
	unique \
	valsort"

AC_ARG_ENABLE(xxslapoverlays,[
SLAPD Overlay Options:])

OL_ARG_ENABLE(overlays,[    --enable-overlays	  enable all available overlays],
	--, [no yes mod])dnl
OL_ARG_ENABLE(accesslog,[    --enable-accesslog	  In-Directory Access Logging overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(auditlog,[    --enable-auditlog	  Audit Logging overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(constraint,[    --enable-constraint	  Attribute Constraint overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(dds,[    --enable-dds  	  Dynamic Directory Services overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(dyngroup,[    --enable-dyngroup	  Dynamic Group overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(dynlist,[    --enable-dynlist	  Dynamic List overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(memberof,[    --enable-memberof	  Reverse Group Membership overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(ppolicy,[    --enable-ppolicy	  Password Policy overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(proxycache,[    --enable-proxycache	  Proxy Cache overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(refint,[    --enable-refint	  Referential Integrity overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(retcode,[    --enable-retcode	  Return Code testing overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(rwm,[    --enable-rwm       	  Rewrite/Remap overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(seqmod,[    --enable-seqmod	  Sequential Modify overlay],
	yes, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(syncprov,[    --enable-syncprov	  Syncrepl Provider overlay],
	yes, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(translucent,[    --enable-translucent  Translucent Proxy overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(unique,[    --enable-unique       Attribute Uniqueness overlay],
	no, [no yes mod], ol_enable_overlays)
OL_ARG_ENABLE(valsort,[    --enable-valsort      Value Sorting overlay],
	no, [no yes mod], ol_enable_overlays)

dnl ----------------------------------------------------------------
AC_ARG_ENABLE(xxliboptions,[
Library Generation & Linking Options])
AC_ENABLE_STATIC
AC_ENABLE_SHARED

dnl ----------------------------------------------------------------

# validate options
if test $ol_enable_slapd = no ; then
	dnl SLAPD was specificallly disabled
	if test $ol_enable_slapi = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-slapi argument])
	fi
	case "$ol_enable_backends" in yes | mod)
		AC_MSG_WARN([slapd disabled, ignoring --enable-backends argument])
	esac
	for i in $Backends; do
		eval "ol_tmp=\$ol_enable_$i"
		if test $ol_tmp != no ; then
			AC_MSG_WARN([slapd disabled, ignoring --enable-$i argument])
			eval "ol_enable_$i=no"
		fi
	done
	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_rlookups = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-rlookups argument])
	fi
	if test $ol_enable_dynacl = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-dynacl argument])
	fi
	if test $ol_enable_aci != no ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-aci argument])
	fi
	if test $ol_enable_rewrite = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable-rewrite argument])
	fi
	dnl overlays
	case "$ol_enable_overlays" in yes | mod)
		AC_MSG_WARN([slapd disabled, ignoring --enable-overlays argument])
	esac
	for i in $Overlays; do
		eval "ol_tmp=\$ol_enable_$i"
		if test $ol_tmp != no ; then
			AC_MSG_WARN([slapd disabled, ignoring --enable-$i argument])
			eval "ol_enable_$i=no"
		fi
	done

	# force settings to no
	ol_enable_slapi=no

	ol_enable_backends=
	ol_enable_overlays=
	ol_enable_modules=no
	ol_enable_rlookups=no
	ol_enable_dynacl=no
	ol_enable_aci=no
	ol_enable_wrappers=no

	ol_enable_rewrite=no

elif test $ol_enable_modules != yes &&
	test $ol_enable_bdb = no &&
	test $ol_enable_dnssrv = no &&
	test $ol_enable_hdb = no &&
	test $ol_enable_ldap = no &&
	test $ol_enable_meta = no &&
	test $ol_enable_monitor = no &&
	test $ol_enable_null = no &&
	test $ol_enable_passwd = no &&
	test $ol_enable_perl = no &&
	test $ol_enable_relay = no &&
	test $ol_enable_shell = no &&
	test $ol_enable_sock = no &&
	test $ol_enable_sql = no ; then
	dnl no slapd backend

	if test $ol_enable_slapd = yes ; then
		AC_MSG_ERROR([slapd requires a backend])
	else
		AC_MSG_WARN([skipping slapd, no backend specified])
		ol_enable_slapd=no
	fi
fi

if test $ol_enable_meta/$ol_enable_ldap = yes/no ; then
	AC_MSG_ERROR([--enable-meta requires --enable-ldap])
fi

if test $ol_enable_lmpasswd = yes ; then
	if test $ol_with_tls = no ; then
		AC_MSG_ERROR([LAN Manager passwords require OpenSSL])
	fi
fi

if test $ol_enable_spasswd = yes ; then
	if test $ol_with_cyrus_sasl = no ; then
		AC_MSG_ERROR([options require --with-cyrus-sasl])
	fi
	ol_with_cyrus_sasl=yes
fi

AC_MSG_RESULT(done)

dnl ----------------------------------------------------------------
dnl Initialize vars
LDAP_LIBS=
BDB_LIBS=
LTHREAD_LIBS=
LUTIL_LIBS=

SLAPD_LIBS=

BUILD_SLAPD=no

BUILD_THREAD=no

BUILD_SLAPI=no
SLAPD_SLAPI_DEPEND=

BUILD_BDB=no
BUILD_DNSSRV=no
BUILD_HDB=no
BUILD_LDAP=no
BUILD_META=no
BUILD_MONITOR=no
BUILD_NULL=no
BUILD_PASSWD=no
BUILD_PERL=no
BUILD_RELAY=no
BUILD_SHELL=no
BUILD_SOCK=no
BUILD_SQL=no

BUILD_ACCESSLOG=no
BUILD_AUDITLOG=no
BUILD_CONSTRAINT=no
BUILD_DDS=no
BUILD_DENYOP=no
BUILD_DYNGROUP=no
BUILD_DYNLIST=no
BUILD_LASTMOD=no
BUILD_MEMBEROF=no
BUILD_PPOLICY=no
BUILD_PROXYCACHE=no
BUILD_REFINT=no
BUILD_RETCODE=no
BUILD_RWM=no
BUILD_SEQMOD=no
BUILD_SYNCPROV=no
BUILD_TRANSLUCENT=no
BUILD_UNIQUE=no
BUILD_VALSORT=no

SLAPD_STATIC_OVERLAYS=
SLAPD_DYNAMIC_OVERLAYS=

SLAPD_MODULES_LDFLAGS=
SLAPD_MODULES_CPPFLAGS=

SLAPD_STATIC_BACKENDS=back-ldif
SLAPD_DYNAMIC_BACKENDS=

SLAPD_PERL_LDFLAGS=
MOD_PERL_LDFLAGS=
PERL_CPPFLAGS=

SLAPD_SQL_LDFLAGS=
SLAPD_SQL_LIBS=
SLAPD_SQL_INCLUDES=

KRB4_LIBS=
KRB5_LIBS=
SASL_LIBS=
TLS_LIBS=
MODULES_LIBS=
SLAPI_LIBS=
LIBSLAPI=
LIBSLAPITOOLS=
AUTH_LIBS=
ICU_LIBS=

SLAPD_SLP_LIBS=
SLAPD_GMP_LIBS=

dnl ================================================================
dnl Checks for programs

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

dnl ----------------------------------------------------------------
dnl
dnl Determine which C translator to use
dnl

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

	case ${CC} in cc_r | xlc_r)
		ol_with_threads=posix
		ol_cv_pthread_create=yes
		;;
	esac
fi

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

	if test "${CC}" = "missing" ; then
		AC_MSG_ERROR([Unable to locate cc(1) or suitable replacement.  Check PATH or set CC.])
	fi
fi

if test -z "${AR}"; then
	AC_CHECK_PROGS(AR,ar gar,missing)

	if test "${AR}" = "missing" ; then
		AC_MSG_ERROR([Unable to locate ar(1) or suitable replacement.  Check PATH or set AR.])
	fi
fi

AC_LIBTOOL_WIN32_DLL
AC_LIBTOOL_DLOPEN
AC_PROG_LIBTOOL

dnl ----------------------------------------------------------------
dnl Perl
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
		PERL_CPPFLAGS="`$PERLBIN -MExtUtils::Embed -e ccopts`"
		PERL_LDFLAGS="`$PERLBIN -MExtUtils::Embed -e ldopts|sed -e 's/ -lc / /' -e 's/ -lc$//'`"

		if test x"$ol_enable_perl" = "xyes" ; then
			SLAPD_PERL_LDFLAGS="$PERL_LDFLAGS"
		else
			MOD_PERL_LDFLAGS="$PERL_LDFLAGS"
		fi
		dnl should check perl version
		ol_link_perl=yes
	fi
fi

AC_PROG_CPP

dnl ----------------------------------------------------------------
dnl Checks for Windows NT
case $host_os in
  *mingw32* ) ac_cv_mingw32=yes ;;
  *cygwin* ) ac_cv_cygwin=yes ;;
esac

dnl ----------------------------------------------------------------
dnl Checks for file extensions
AC_EXEEXT
AC_OBJEXT
AC_DEFINE_UNQUOTED(EXEEXT, "${EXEEXT}", [defined to be the EXE extension])

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

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

dnl ----------------------------------------------------------------
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 ----------------------------------------------------------------
dnl Check for AIX security library
AC_CHECK_LIB(s, afopen, [
	AUTH_LIBS=-ls
	AC_DEFINE(HAVE_AIX_SECURITY,1,[define if you have AIX security lib])
])

dnl ----------------------------------------------------------------
dnl Check for IBM OS/390
case "$target" in
*-ibm-openedition)
	ac_cv_func_getopt=no
	AC_DEFINE(BOTH_STRINGS_H,1,[define to use both <string.h> and <strings.h>])
	;;
esac

dnl ----------------------------------------------------------------
dnl Check for module support
ol_link_modules=no
WITH_MODULES_ENABLED=no
if test $ol_enable_modules != no ; then
	AC_CHECK_HEADERS(ltdl.h)

	if test $ac_cv_header_ltdl_h = no ; then
		AC_MSG_ERROR([could not locate libtool ltdl.h])
	fi

	AC_CHECK_LIB(ltdl, lt_dlinit, [
		MODULES_LIBS=-lltdl
		AC_DEFINE(HAVE_LIBLTDL,1,[define if you have libtool -ltdl])
	])

	if test "$ac_cv_lib_ltdl_lt_dlinit" = no ; then
		AC_MSG_ERROR([could not locate libtool -lltdl])
	fi
	ol_link_modules=yes
	WITH_MODULES_ENABLED=yes

else
	for i in $Backends; do
		eval "ol_tmp=\$ol_enable_$i"
		if test $ol_tmp = mod ; then
			AC_MSG_WARN([building static $i backend])
			eval "ol_enable_$i=yes"
		fi
	done
	for i in $Overlays; do
		eval "ol_tmp=\$ol_enable_$i"
		if test $ol_tmp = mod ; then
			AC_MSG_WARN([building static $i overlay])
			eval "ol_enable_$i=yes"
		fi
	done
fi

dnl ----------------------------------------------------------------
dnl Checks for header files.
OL_HEADER_STDC

if test $ol_cv_header_stdc != yes; then
	AC_MSG_WARN([could not locate Standard C compliant headers])
fi

AC_HEADER_DIRENT
AC_HEADER_SYS_WAIT
AC_HEADER_TIOCGWINSZ

AC_CHECK_HEADERS(	\
	arpa/inet.h		\
	arpa/nameser.h	\
	assert.h		\
	bits/types.h	\
	conio.h			\
	crypt.h			\
	direct.h		\
	errno.h			\
	fcntl.h			\
	filio.h			\
	getopt.h		\
	grp.h			\
	io.h			\
	libutil.h		\
	limits.h		\
	locale.h		\
	malloc.h		\
	memory.h		\
	psap.h			\
	pwd.h			\
	process.h		\
	sgtty.h			\
	shadow.h		\
	stddef.h		\
	string.h		\
	strings.h		\
	sysexits.h		\
	sys/file.h		\
	sys/filio.h		\
	sys/fstyp.h		\
	sys/errno.h		\
	sys/ioctl.h		\
	sys/param.h		\
	sys/privgrp.h	\
	sys/resource.h	\
	sys/select.h	\
	sys/socket.h	\
	sys/stat.h		\
	sys/syslog.h	\
	sys/time.h		\
	sys/types.h		\
	sys/uio.h		\
	sys/vmount.h	\
	syslog.h		\
	termios.h		\
	unistd.h		\
	utime.h			\
)

dnl Only check Winsock on MinGW
if test "$ac_cv_mingw32" = yes ; then
	AC_CHECK_HEADERS( winsock.h winsock2.h )
fi

AC_CHECK_HEADERS( resolv.h, [], [],
[$ac_includes_default
#include <netinet/in.h>
])

AC_CHECK_HEADERS( netinet/tcp.h, [], [],
[$ac_includes_default
#include <netinet/in.h>
])

AC_CHECK_HEADERS( sys/ucred.h, [], [],
[$ac_includes_default
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
])

dnl ----------------------------------------------------------------
dnl Checks for libraries

AC_CHECK_FUNCS( sigaction sigset )

dnl HP-UX requires -lV3
dnl this is not needed on newer versions of HP-UX
if test $ac_cv_func_sigaction = no && test $ac_cv_func_sigaction = no ; then
	AC_CHECK_LIB(V3, sigset)
fi

dnl The following is INTENTIONALLY scripted out because shell does not
dnl support variable names with the '@' character, which is what
dnl autoconf would try to generate if one merely used AC_SEARCH_LIBS
if test "$ac_cv_header_winsock_h" = yes; then
AC_CACHE_CHECK([for winsock], [ol_cv_winsock],
save_LIBS="$LIBS"
for curlib in ws2_32 wsock32; do
	LIBS="$LIBS -l$curlib"
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <winsock.h>
			]], [[
			socket(0,0,0);
			select(0,NULL,NULL,NULL,NULL);
			closesocket(0);
			gethostname(NULL,0);
			]])],[ol_cv_winsock=yes],[ol_cv_winsock=no])

	if test $ol_cv_winsock = yes; then
		AC_DEFINE(HAVE_WINSOCK, 1, [define if you have winsock])
		ac_cv_func_socket=yes
		ac_cv_func_select=yes
		ac_cv_func_closesocket=yes
		ac_cv_func_gethostname=yes
		if test $curlib = ws2_32; then
			ol_cv_winsock=winsock2
			AC_DEFINE(HAVE_WINSOCK2, 1,
				  [define if you have winsock2])
		fi
		break
	fi
	LIBS="$save_LIBS"
done)
fi

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

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

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

if test "${ac_cv_header_winsock_h}" != yes; then
	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
fi

dnl check to see if system call automatically restart
dnl AC_SYS_RESTARTABLE_SYSCALLS

dnl ----------------------------------------------------------------
AC_CHECK_FUNCS( poll )
if test $ac_cv_func_poll = yes; then
AC_CHECK_HEADERS( poll.h sys/poll.h )
fi

dnl ----------------------------------------------------------------
AC_CHECK_HEADERS( sys/epoll.h )
if test "${ac_cv_header_sys_epoll_h}" = yes; then
	AC_MSG_CHECKING(for epoll system call)
	AC_RUN_IFELSE([AC_LANG_SOURCE([[int main(int argc, char **argv)
{
	int epfd = epoll_create(256);
	exit (epfd == -1 ? 1 : 0);
}]])],[AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_EPOLL,1, [define if your system supports epoll])],[AC_MSG_RESULT(no)],[AC_MSG_RESULT(no)])
fi

dnl ----------------------------------------------------------------
AC_CHECK_HEADERS( sys/devpoll.h )
dnl "/dev/poll" needs <sys/poll.h> as well...
if test "${ac_cv_header_sys_devpoll_h}" = yes \
		-a "${ac_cv_header_poll_h}" = yes ; \
then
	AC_MSG_CHECKING(for /dev/poll)
	AC_RUN_IFELSE([AC_LANG_SOURCE([[int main(int argc, char **argv)
{
	int devpollfd = open("/dev/poll", /* O_RDWR */ 2);
	exit (devpollfd == -1 ? 1 : 0);
}]])],[AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_DEVPOLL,1, [define if your system supports /dev/poll])],[AC_MSG_RESULT(no)],[AC_MSG_RESULT(no)])
fi

dnl ----------------------------------------------------------------
# strerror checks
OL_STRERROR

dnl ----------------------------------------------------------------
dnl require POSIX regex
AC_CHECK_HEADERS( regex.h, [], [],
[$ac_includes_default
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
])

if test "$ac_cv_header_regex_h" != yes ; then
	AC_MSG_ERROR([POSIX regex.h required.])
fi
AC_SEARCH_LIBS(regfree, [regex gnuregex],
	:, 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

dnl ----------------------------------------------------------------
dnl UUID Support

have_uuid=no
AC_CHECK_HEADERS(sys/uuid.h)
if test $ac_cv_header_sys_uuid_h = yes ; then
	save_LIBS="$LIBS"
	AC_SEARCH_LIBS([uuid_to_str], [uuid], [have_uuid=yes], :)
	LIBS="$save_LIBS"

	if test have_uuid = yes ; then
		AC_DEFINE(HAVE_UUID_TO_STR,1,
			[define if you have uuid_to_str()])

		test "$ac_cv_search_uuid_to_str" = "none required" || \
			SLAPD_LIBS="$SLAPD_LIBS $ac_cv_search_uuid_to_str"
	fi
fi

dnl Look for uuid_generate
if test $have_uuid = no ; then
	AC_CHECK_HEADERS(uuid/uuid.h)
	if test $ac_cv_header_uuid_uuid_h = yes ; then
		save_LIBS="$LIBS"
		AC_SEARCH_LIBS([uuid_generate], [uuid], [have_uuid=yes], :)
		LIBS="$save_LIBS"

		if test have_uuid = yes ; then
			AC_DEFINE(HAVE_UUID_GENERATE,1,
				[define if you have uuid_generate()])

			test "$ac_cv_search_uuid_generate" = "none required" || \
				SLAPD_LIBS="$SLAPD_LIBS $ac_cv_search_uuid_generate"
		fi
	fi
fi

dnl For windows, check for the need of RPCRT for UUID function support
if test $have_uuid = no ; then
	AC_MSG_CHECKING(to see if -lrpcrt4 is needed for win32 UUID support)
	save_LIBS="$LIBS"
	LIBS="$LIBS -lrpcrt4"
	AC_LINK_IFELSE([AC_LANG_PROGRAM([[
		int __stdcall UuidCreate(void *);
		int __stdcall UuidToStringA(void *,void **);
		]], [[
		UuidCreate(0);
		UuidToStringA(0,0);
		]])],[need_rpcrt=yes],[need_rpcrt=no])
	if test $need_rpcrt = yes; then
		SLAPD_LIBS="$SLAPD_LIBS -lrpcrt4"
	fi
	LIBS="$save_LIBS"
	AC_MSG_RESULT($need_rpcrt)
fi

dnl ----------------------------------------------------------------
dnl Check for resolver routines
OL_RESOLVER_LINK

ol_link_dnssrv=no
if test "$ol_cv_lib_resolver" != no ; then
	AC_DEFINE(HAVE_RES_QUERY,1,
		[define if you have res_query()])

	if test "$ol_enable_dnssrv" != no ; then
		ol_link_dnssrv=yes
	fi

	if test "$ol_cv_lib_resolver" != yes ; then
		LIBS="$ol_cv_lib_resolver $LIBS"
	fi
fi

if test "$ol_enable_dnssrv" = yes || test "$ol_enable_dnssrv" = mod ; then
	if test "$ol_link_dnssrv" = no ; then
		AC_MSG_ERROR([DNSSRV requires res_query()])
	fi
else
	ol_enable_dnssrv=no
fi

AC_CHECK_FUNCS( hstrerror )

dnl ----------------------------------------------------------------
dnl PF_INET6 support requires getaddrinfo and INET6_ADDRSTRLEN
dnl PF_LOCAL may use getaddrinfo in available
AC_CHECK_FUNCS( getaddrinfo getnameinfo gai_strerror inet_ntop )

ol_link_ipv6=no
if test $ac_cv_func_getaddrinfo = no || test $ac_cv_func_inet_ntop = no ; then
	if test $ol_enable_ipv6 = yes ; then
		AC_MSG_ERROR([IPv6 support requires getaddrinfo() and inet_ntop()])
	fi
elif test $ol_enable_ipv6 != no ; then
	AC_CACHE_CHECK([INET6_ADDRSTRLEN],[ol_cv_inet6_addrstrlen],[
		AC_EGREP_CPP(__has_inet6_addrstrlen__,[
#			include <netinet/in.h>
#			ifdef INET6_ADDRSTRLEN
				__has_inet6_addrstrlen__;
#			endif
		], [ol_cv_inet6_addrstrlen=yes], [ol_cv_inet6_addrstrlen=no])])


	AC_CACHE_CHECK([struct sockaddr_storage],ol_cv_struct_sockaddr_storage,[
		AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include <sys/types.h>
#include <sys/socket.h>
]], [[
			struct sockaddr_storage ss;
]])],[ol_cv_struct_sockaddr_storage=yes],[ol_cv_struct_sockaddr_storage=no])])

	if test $ol_cv_inet6_addrstrlen = yes &&
	   test $ol_cv_struct_sockaddr_storage = yes ; then
		ol_link_ipv6=yes
	elif test $ol_enable_ipv6 = yes &&
	     test $ol_cv_inet6_addrstrlen = no ; then
		AC_MSG_ERROR([IPv6 support requires INET6_ADDRSTRLEN])
	elif test $ol_enable_ipv6 = yes &&
	     test $ol_cv_struct_sockaddr_storage = no ; then
		AC_MSG_ERROR([IPv6 support requires struct sockaddr_storage])
	fi
fi

if test $ol_enable_local != no ; then
	AC_CHECK_HEADERS( sys/un.h )

	if test $ol_enable_local = auto ; then
		ol_enable_local=$ac_cv_header_sys_un_h
	elif test $ac_cv_header_sys_un_h = no ; then
		AC_MSG_ERROR([AF_LOCAL domain support requires sys/un.h])
	fi
fi

dnl ----------------------------------------------------------------
dnl TLS/SSL
	
if test $ol_with_tls = yes ; then
	ol_with_tls=auto
fi

ol_link_tls=no
if test $ol_with_tls = openssl || test $ol_with_tls = auto ; then
	AC_CHECK_HEADERS(openssl/ssl.h)

	if test $ac_cv_header_openssl_ssl_h = yes ; then
		AC_CHECK_LIB(ssl, SSL_library_init,
			[have_openssl=yes
			need_rsaref=no], [have_openssl=no],
			[-lcrypto])

		if test $have_openssl = no ; then
			AC_CHECK_LIB(ssl, ssl3_accept, 
				[have_openssl=yes
				need_rsaref=yes], [have_openssl=no],
				[-lcrypto -lRSAglue -lrsaref])
		fi

		if test $have_openssl = yes ; then
			ol_with_tls=openssl
			ol_link_tls=yes

			AC_DEFINE(HAVE_OPENSSL, 1, 
				[define if you have OpenSSL])

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

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

			OL_SSL_COMPAT
			if test $ol_cv_ssl_crl_compat = yes ; then
				AC_DEFINE(HAVE_OPENSSL_CRL, 1, 
					[define if you have OpenSSL with CRL checking capability])
			fi
		fi
	fi
fi

if test $ol_link_tls = no ; then
	if test $ol_with_tls = gnutls || test $ol_with_tls = auto ; then
		AC_CHECK_HEADERS(gnutls/gnutls.h)

		if test $ac_cv_header_gnutls_gnutls_h = yes ; then
			AC_CHECK_LIB(gnutls, gnutls_init,
				[have_gnutls=yes], [have_gnutls=no])

			if test $have_gnutls = yes ; then
				ol_with_tls=gnutls
				ol_link_tls=yes

				TLS_LIBS="-lgnutls"

				AC_DEFINE(HAVE_GNUTLS, 1, 
					[define if you have GNUtls])
			fi
		fi
	fi
fi

WITH_TLS=no
if test $ol_link_tls = yes ; then
	AC_DEFINE(HAVE_TLS, 1, [define if you have TLS])
	WITH_TLS=yes
elif test $ol_with_tls = auto ; then
	AC_MSG_WARN([Could not locate TLS/SSL package])
	AC_MSG_WARN([TLS data protection not supported!])
elif test $ol_with_tls != no ; then
	AC_MSG_ERROR([Could not locate TLS/SSL package])
else
	AC_MSG_WARN([TLS data protection not supported!])
fi

dnl ----------------------------------------------------------------
dnl LAN Manger password checking requires DES from OpenSSL
if test $ol_enable_lmpasswd != no; then
	if test $ol_link_tls != yes ; then
		AC_MSG_ERROR([LAN Manager passwords require OpenSSL])
	fi

	AC_DEFINE(SLAPD_LMHASH, 1, [define to support LAN Manager passwords])
fi

dnl ----------------------------------------------------------------
dnl Threads?
ol_link_threads=no

case $ol_with_threads in auto | yes | nt)

	OL_NT_THREADS

	if test "$ol_cv_nt_threads" = yes ; then
		ol_link_threads=nt
		ol_with_threads=found
		ol_with_yielding_select=yes

		AC_DEFINE(HAVE_NT_SERVICE_MANAGER,1,[if you have NT Service Manager])
		AC_DEFINE(HAVE_NT_EVENT_LOG,1,[if you have NT Event Log])
	fi

	if test $ol_with_threads = nt ; then
		AC_MSG_ERROR([could not locate NT Threads])
	fi
	;;
esac

case $ol_with_threads in auto | yes | posix)

	AC_CHECK_HEADERS(pthread.h)

	if test $ac_cv_header_pthread_h = yes ; then
		OL_POSIX_THREAD_VERSION

		if test $ol_cv_pthread_version != 0 ; then
			AC_DEFINE_UNQUOTED(HAVE_PTHREADS,$ol_cv_pthread_version,
				[define to pthreads API spec revision])
		else
			AC_MSG_ERROR([unknown pthread version])
		fi

		# consider threads found
		ol_with_threads=found

		OL_HEADER_LINUX_THREADS
		OL_HEADER_GNU_PTH_PTHREAD_H

		if test $ol_cv_header_gnu_pth_pthread_h = no ; then
			AC_CHECK_HEADERS(sched.h)
		fi

		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 	[skipped] pthread_create() with -mt (Solaris) [disabled]
		dnl 	pthread_create() with -kthread (FreeBSD)
		dnl 	pthread_create() with -pthread (FreeBSD/Digital Unix)
		dnl 	pthread_create() with -pthreads (?)
		dnl 	pthread_create() with -mthreads (AIX)
		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_CACHE_CHECK([for pthread_create in default libraries],
			ol_cv_pthread_create,[
			AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM],
				[ol_cv_pthread_create=yes],
				[ol_cv_pthread_create=no],
				[AC_TRY_LINK(OL_PTHREAD_TEST_INCLUDES,OL_PTHREAD_TEST_FUNCTION,
					[ol_cv_pthread_create=yes],
					[ol_cv_pthread_create=no])])])

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

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

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

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

		OL_PTHREAD_TRY([-threads],	[ol_cv_pthread_threads])

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

		OL_PTHREAD_TRY([-lpthreads],[ol_cv_pthread_lib_lpthreads])

		if test $ol_link_threads != no ; then
			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, and thr_yield for Solaris
			AC_CHECK_FUNCS(sched_yield pthread_yield thr_yield)

			if test $ac_cv_func_sched_yield = no &&
			   test $ac_cv_func_pthread_yield = no &&
			   test $ac_cv_func_thr_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,
						[Define if you have the sched_yield function.])
					ac_cv_func_sched_yield=yes],
					[ac_cv_func_sched_yield=no])
			fi
			if test $ac_cv_func_sched_yield = no &&
			   test $ac_cv_func_pthread_yield = no &&
			   test "$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_rwlock_destroy with <pthread.h>
			dnl as pthread_rwlock_t may not be defined.
			AC_CACHE_CHECK([for pthread_rwlock_destroy with <pthread.h>],
				[ol_cv_func_pthread_rwlock_destroy], [
				dnl save the flags
				AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <pthread.h>
pthread_rwlock_t rwlock;
]], [[pthread_rwlock_destroy(&rwlock);]])],[ol_cv_func_pthread_rwlock_destroy=yes],[ol_cv_func_pthread_rwlock_destroy=no])
			])
			if test $ol_cv_func_pthread_rwlock_destroy = yes ; then
				AC_DEFINE(HAVE_PTHREAD_RWLOCK_DESTROY,1,
					[define if you have pthread_rwlock_destroy function])
			fi

			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_LINK_IFELSE([AC_LANG_PROGRAM([[
#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_CACHE_CHECK([if pthread_create() works],
				ol_cv_pthread_create_works,[
			AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM],
				[ol_cv_pthread_create_works=yes],
				[ol_cv_pthread_create_works=no],
				[dnl assume yes
				ol_cv_pthread_create_works=yes])])

			if test $ol_cv_pthread_create_works = no ; then
				AC_MSG_ERROR([pthread_create is not usable, check environment settings])
			fi

			ol_replace_broken_yield=no
dnl			case "$target" in
dnl			*-*-linux*) 
dnl				AC_CHECK_FUNCS(nanosleep)
dnl				ol_replace_broken_yield=yes
dnl			;;
dnl			esac

			if test $ol_replace_broken_yield = yes ; then
				AC_DEFINE([REPLACE_BROKEN_YIELD],1,
					[define if sched_yield yields the entire process])
			fi

			dnl Check if select causes an yield
			if test $ol_with_yielding_select = auto ; then
				AC_CACHE_CHECK([if select yields when using pthreads],
					ol_cv_pthread_select_yields,[
				AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>
#ifndef NULL
#define NULL (void*) 0
#endif

static int fildes[2];

static void *task(p)
	void *p;
{
	int i;
	struct timeval tv;

	fd_set rfds;

	tv.tv_sec=10;
	tv.tv_usec=0;

	FD_ZERO(&rfds);
	FD_SET(fildes[0], &rfds);

	/* we're not interested in any fds */
	i = select(FD_SETSIZE, &rfds, NULL, NULL, &tv);

	if(i < 0) {
		perror("select");
		exit(10);
	}

	exit(0); /* if we exit here, the select blocked the whole process */
}

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

	/* create a pipe to select */
	if(pipe(&fildes[0])) {
		perror("select");
		exit(1);
	}

#ifdef HAVE_PTHREAD_SETCONCURRENCY
	(void) pthread_setconcurrency(2);
#else
#ifdef HAVE_THR_SETCONCURRENCY
	/* Set Solaris LWP concurrency to 2 */
	thr_setconcurrency(2);
#endif
#endif

#if HAVE_PTHREADS < 6
	pthread_create(&t, pthread_attr_default, task, NULL);
#else
	pthread_create(&t, NULL, task, NULL);
#endif

	/* make sure task runs first */
#ifdef HAVE_THR_YIELD
	thr_yield();
#elif defined( HAVE_SCHED_YIELD )
	sched_yield();
#elif defined( HAVE_PTHREAD_YIELD )
	pthread_yield();
#endif

	exit(2);
}]])],[ol_cv_pthread_select_yields=no],[ol_cv_pthread_select_yields=yes],[ol_cv_pthread_select_yields=cross])])

				if test $ol_cv_pthread_select_yields = cross ; then
					AC_MSG_ERROR([crossing compiling: use --with-yielding_select=yes|no|manual])
				fi

				if test $ol_cv_pthread_select_yields = yes ; then
					ol_with_yielding_select=yes
				fi
			fi

			dnl restore flags
			CPPFLAGS="$save_CPPFLAGS"
			LIBS="$save_LIBS"
		else
			AC_MSG_ERROR([could not locate usable POSIX Threads])
		fi
	fi

	if test $ol_with_threads = posix ; then
		AC_MSG_ERROR([could not locate POSIX Threads])
	fi
	;;
esac

case $ol_with_threads in auto | yes | mach)

	dnl check for Mach CThreads
	AC_CHECK_HEADERS(mach/cthreads.h cthreads.h)
	if test $ac_cv_header_mach_cthreads_h = yes ; then
		ol_with_threads=found

		dnl check for cthreads support in current $LIBS
		AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes])

		if test $ol_link_threads = no ; then
			dnl try -all_load
			dnl this test needs work
			AC_CACHE_CHECK([for cthread_fork with -all_load],
				[ol_cv_cthread_all_load], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="-all_load $LIBS"
				AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <mach/cthreads.h>]], [[
					cthread_fork((void *)0, (void *)0);
					]])],[ol_cv_cthread_all_load=yes],[ol_cv_cthread_all_load=no])
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_cthread_all_load = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -all_load"
				ol_link_threads=mach
				ol_with_threads=found
			fi
		fi

	elif test $ac_cv_header_cthreads_h = yes ; then
		dnl Hurd variant of Mach Cthreads
		dnl uses <cthreads.h> and -lthreads

		ol_with_threads=found
 
		dnl save the flags
		save_LIBS="$LIBS"
		LIBS="$LIBS -lthreads"
		AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes])
		LIBS="$save_LIBS"

		if test $ol_link_threads = yes ; then
			LTHREAD_LIBS="-lthreads"
			ol_link_threads=mach
			ol_with_threads=found
		else
			AC_MSG_ERROR([could not link with Mach CThreads])
		fi

	elif test $ol_with_threads = mach ; then
		AC_MSG_ERROR([could not locate Mach CThreads])
	fi

	if test $ol_link_threads = mach ; then
		AC_DEFINE(HAVE_MACH_CTHREADS,1,
			[define if you have Mach Cthreads])
	elif test $ol_with_threads = found ; then
		AC_MSG_ERROR([could not link with Mach CThreads])
	fi
	;;
esac

case $ol_with_threads in auto | yes | pth)

	AC_CHECK_HEADERS(pth.h)

	if test $ac_cv_header_pth_h = yes ; then
		AC_CHECK_LIB(pth, pth_version, [have_pth=yes], [have_pth=no])

		if test $have_pth = yes ; then
			AC_DEFINE(HAVE_GNU_PTH,1,[if you have GNU Pth])
			LTHREAD_LIBS="$LTHREAD_LIBS -lpth"
			ol_link_threads=pth
			ol_with_threads=found

			if test $ol_with_yielding_select = auto ; then
				ol_with_yielding_select=yes
			fi
		fi
	fi
	;;
esac

case $ol_with_threads in auto | yes | lwp)

	dnl check for SunOS5 LWP
	AC_CHECK_HEADERS(thread.h synch.h)
	if test $ac_cv_header_thread_h = yes &&
	   test $ac_cv_header_synch_h = yes ; then
		AC_CHECK_LIB(thread, thr_create, [have_thr=yes], [have_thr=no])

		if test $have_thr = yes ; then
			AC_DEFINE(HAVE_THR,1,
				[if you have Solaris LWP (thr) package])
			LTHREAD_LIBS="$LTHREAD_LIBS -lthread"
			ol_link_threads=thr

			if test $ol_with_yielding_select = auto ; then
				ol_with_yielding_select=yes
			fi

			dnl Check for setconcurreny functions
			AC_CHECK_FUNCS(	\
				thr_setconcurrency \
				thr_getconcurrency \
			)
		fi
	fi

	dnl check for SunOS4 LWP
	AC_CHECK_HEADERS(lwp/lwp.h)
	if test $ac_cv_header_lwp_lwp_h = yes ; then
		AC_CHECK_LIB(lwp, lwp_create, [have_lwp=yes], [have_lwp=no])

		if test $have_lwp = yes ; then
			AC_DEFINE(HAVE_LWP,1,
				[if you have SunOS LWP package])
			LTHREAD_LIBS="$LTHREAD_LIBS -llwp"
			ol_link_threads=lwp

			if test $ol_with_yielding_select = auto ; then
				ol_with_yielding_select=no
			fi
		fi
	fi
	;;
esac

if test $ol_with_yielding_select = yes ; then
	AC_DEFINE(HAVE_YIELDING_SELECT,1,
		[define if select implicitly yields])
fi

if test $ol_with_threads = manual ; then
	dnl User thinks he can manually configure threads.
	ol_link_threads=yes

	AC_MSG_WARN([thread defines and link options must be set manually])

	AC_CHECK_HEADERS(pthread.h sched.h)
	AC_CHECK_FUNCS(sched_yield pthread_yield)
	OL_HEADER_LINUX_THREADS

	AC_CHECK_HEADERS(mach/cthreads.h)
	AC_CHECK_HEADERS(lwp/lwp.h)
	AC_CHECK_HEADERS(thread.h synch.h)
fi

if test $ol_link_threads != no && test $ol_link_threads != nt ; then
	dnl needed to get reentrant/threadsafe versions
	dnl
	AC_DEFINE(REENTRANT,1)
	AC_DEFINE(_REENTRANT,1)
	AC_DEFINE(THREAD_SAFE,1)
	AC_DEFINE(_THREAD_SAFE,1)
	AC_DEFINE(THREADSAFE,1)
	AC_DEFINE(_THREADSAFE,1)
	AC_DEFINE(_SGI_MP_SOURCE,1)

	dnl The errno declaration may dependent upon _REENTRANT.
	dnl If it does, we must link with thread support.
	AC_CACHE_CHECK([for thread specific errno],
		[ol_cv_errno_thread_specific], [
		AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], [[errno = 0;]])],[ol_cv_errno_thread_specific=yes],[ol_cv_errno_thread_specific=no])
	])

	dnl The h_errno declaration may dependent upon _REENTRANT.
	dnl If it does, we must link with thread support.
	AC_CACHE_CHECK([for thread specific h_errno],
		[ol_cv_h_errno_thread_specific], [
		AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[h_errno = 0;]])],[ol_cv_h_errno_thread_specific=yes],[ol_cv_h_errno_thread_specific=no])
	])

	if test $ol_cv_errno_thread_specific != yes ||
	   test $ol_cv_h_errno_thread_specific != yes ; then
		LIBS="$LTHREAD_LIBS $LIBS"
		LTHREAD_LIBS=""
	fi

dnl When in thread environment, use 
dnl		#if defined( HAVE_REENTRANT_FUNCTIONS ) || defined( HAVE_FUNC_R )
dnl			func_r(...);
dnl		#else
dnl		#	if defined( HAVE_THREADS ) 
dnl				/* lock */
dnl		#	endif
dnl				func(...);
dnl		#	if defined( HAVE_THREADS ) 
dnl				/* unlock */
dnl		#	endif
dnl		#endif
dnl
dnl HAVE_REENTRANT_FUNCTIONS is derived from:
dnl		_POSIX_REENTRANT_FUNCTIONS
dnl		_POSIX_THREAD_SAFE_FUNCTIONS
dnl		_POSIX_THREADSAFE_FUNCTIONS
dnl
dnl		and is currently defined in <ldap_pvt_thread.h>
dnl
dnl HAVE_THREADS is defined by <ldap_pvt_thread.h> iff -UNO_THREADS
dnl 
dnl libldap/*.c should only include <ldap_pvt_thread.h> iff
dnl LDAP_R_COMPILE is defined.  ie:
dnl		#ifdef LDAP_R_COMPILE
dnl		#	include <ldap_pvt_thread.h>
dnl		#endif
dnl
dnl LDAP_R_COMPILE is defined by libldap_r/Makefile.in
dnl specifically for compiling the threadsafe version of
dnl	the ldap library (-lldap_r).
dnl		
dnl	dnl check for reentrant/threadsafe functions
dnl	dnl
dnl	dnl note: these should only be used when linking
dnl	dnl		with $LTHREAD_LIBS
dnl	dnl
dnl	save_CPPFLAGS="$CPPFLAGS"
dnl	save_LIBS="$LIBS"
dnl	LIBS="$LTHREAD_LIBS $LIBS"
dnl	AC_CHECK_FUNCS(	\
dnl		gmtime_r \
dnl		gethostbyaddr_r gethostbyname_r \
dnl		feof_unlocked unlocked_feof \
dnl		putc_unlocked unlocked_putc \
dnl		flockfile ftrylockfile \
dnl	)
dnl	CPPFLAGS="$save_CPPFLAGS"
dnl	LIBS="$save_LIBS"
fi  

if test $ol_link_threads = no ; then
	if test $ol_with_threads = yes ; then
		AC_MSG_ERROR([no suitable thread support])
	fi

	if test $ol_with_threads = auto ; then
		AC_MSG_WARN([no suitable thread support, disabling threads])
		ol_with_threads=no
	fi

	AC_DEFINE(NO_THREADS,1,
		[define if you have (or want) no threads])
	LTHREAD_LIBS=""
	BUILD_THREAD=no
else
	BUILD_THREAD=yes
fi

if test $ol_link_threads != no ; then
	AC_DEFINE(LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE,1,
		[define to 1 if library is thread safe])
fi

dnl ----------------------------------------------------------------
dnl Tests for reentrant functions necessary to build -lldap_r
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

dnl ----------------------------------------------------------------
ol_link_bdb=no 

if test $ol_enable_bdb/$ol_enable_hdb != no/no; then
	OL_BERKELEY_DB

	if test $ol_cv_berkeley_db = no ; then
		AC_MSG_ERROR(BDB/HDB: BerkeleyDB not available)
	fi

	AC_DEFINE(HAVE_BERKELEY_DB,1,
		[define this if Berkeley DB is available])

	dnl $ol_cv_lib_db should be yes or -ldb
	dnl (it could be no, but that would be an error
	if test $ol_cv_lib_db != yes ; then
		BDB_LIBS="$BDB_LIBS $ol_cv_lib_db"
	fi

	OL_BDB_COMPAT

	if test $ol_cv_bdb_compat != yes ; then
		AC_MSG_ERROR([BDB/HDB: BerkeleyDB version incompatible])
	fi

	SLAPD_LIBS="$SLAPD_LIBS \$(BDB_LIBS)"

	ol_link_bdb=yes 
fi

dnl ----------------------------------------------------------------

if test $ol_enable_dynamic = yes && test $enable_shared = yes ; then
	BUILD_LIBS_DYNAMIC=shared
	AC_DEFINE(LDAP_LIBS_DYNAMIC, 1, [define if LDAP libs are dynamic])
	LTSTATIC=""
else
	BUILD_LIBS_DYNAMIC=static
	LTSTATIC="-static"
fi
AC_SUBST(LTSTATIC)dnl

dnl ----------------------------------------------------------------
if test $ol_enable_wrappers != no ; then
	AC_CHECK_HEADERS(tcpd.h,[
		AC_MSG_CHECKING([for TCP wrappers library])
		save_LIBS="$LIBS"
		LIBS="$LIBS -lwrap"
		AC_LINK_IFELSE([AC_LANG_PROGRAM([[
#include <tcpd.h>
int allow_severity = 0;
int deny_severity  = 0;

struct request_info *req;
		]], [[
hosts_access(req)
		]])],[AC_MSG_RESULT([-lwrap])
		have_wrappers=yes
		LIBS="$save_LIBS"],[
		dnl try with -lnsl
		LIBS="$LIBS -lnsl"
		AC_TRY_LINK([
#include <tcpd.h>
int allow_severity = 0;
int deny_severity  = 0;

struct request_info *req;
		],[
hosts_access(req)
		],[AC_MSG_RESULT([-lwrap -lnsl])
		have_wrappers=yes
		LIBS="$save_LIBS -lnsl"],[
		AC_MSG_RESULT(no)
		have_wrappers=no
		LIBS=$save_LIBS])])],[have_wrappers=no])

	if test $have_wrappers = yes ; then
		AC_DEFINE(HAVE_TCPD,1, [define if you have -lwrap])
		WRAP_LIBS="-lwrap"
	elif test $ol_enable_wrappers = yes ; then
		AC_MSG_ERROR([could not find TCP wrappers, select apppropriate options or disable])
	else
		AC_MSG_WARN([could not find TCP wrappers, support disabled])
		WRAP_LIBS=""
	fi
fi

dnl ----------------------------------------------------------------
if test $ol_enable_syslog != no ; then
	AC_CHECK_FUNC(openlog)
	if test $ac_cv_func_openlog = no && test $ol_enable_syslog = yes; then
		AC_MSG_ERROR(could not find syslog, select appropriate options or disable)
	fi
	ol_enable_syslog=$ac_cv_func_openlog
fi

dnl ----------------------------------------------------------------
dnl SQL
ol_link_sql=no
if test $ol_enable_sql != no ; then
	AC_CHECK_HEADERS(sql.h sqlext.h,[],[
		AC_MSG_ERROR([could not locate SQL headers])
	])

	sql_LIBS="$LIBS"
	LIBS="$LTHREAD_LIBS"

	if test $ol_with_odbc = auto ; then
		ol_with_odbc="iodbc unixodbc"
	fi

	for odbc in $ol_with_odbc ; do
		if test $ol_link_sql = no ; then
			case $odbc in
			iodbc)
				AC_CHECK_LIB(iodbc, SQLDriverConnect, [have_iodbc=yes], [have_iodbc=no])
				if test $have_iodbc = yes ; then
					ol_link_sql="-liodbc"
				fi
				;;

			unixodbc)
				AC_CHECK_LIB(odbc, SQLDriverConnect, [have_odbc=yes], [have_odbc=no])
				if test $have_odbc = yes ; then
					ol_link_sql="-lodbc"
				fi
				;;

			*)
				AC_MSG_ERROR([unknown ODBC library])
				;;
			esac
		fi
	done

	LIBS="$sql_LIBS"

	if test $ol_link_sql != no ; then
		SLAPD_SQL_LIBS="$ol_link_sql"

	elif test $ol_enable_sql != auto ; then
		AC_MSG_ERROR([could not locate suitable ODBC library])
	fi
fi

dnl ----------------------------------------------------------------
dnl International Components for Unicode
OL_ICU
if test "$ol_icu" = no ; then
	AC_MSG_WARN([ICU not available])
else
	ICU_LIBS="$ol_icu"
fi
dnl ----------------------------------------------------------------
dnl
dnl Check for Cyrus SASL
dnl
WITH_SASL=no
ol_link_sasl=no
ol_link_spasswd=no
if test $ol_with_cyrus_sasl != no ; then
	AC_CHECK_HEADERS(sasl/sasl.h sasl.h)

	if test $ac_cv_header_sasl_sasl_h = yes ||
	   test $ac_cv_header_sasl_h = yes; then
		AC_CHECK_LIB(sasl2, sasl_client_init,
			[ol_link_sasl="-lsasl2"],
			[AC_CHECK_LIB(sasl, sasl_client_init,
				[ol_link_sasl="-lsasl"])])
	fi

	if test $ol_link_sasl = no ; then
		if test $ol_with_cyrus_sasl != auto ; then
			AC_MSG_ERROR([Could not locate Cyrus SASL])
		else
			AC_MSG_WARN([Could not locate Cyrus SASL])
			AC_MSG_WARN([SASL authentication not supported!])
			if test $ol_link_tls = no ; then
				AC_MSG_WARN([Strong authentication not supported!])
			fi
		fi
	else
		OL_SASL_COMPAT
		if test $ol_cv_sasl_compat = no ; then
			ol_link_sasl=no
			AC_MSG_ERROR([Cyrus SASL library located but is incompatible])
		fi

		AC_DEFINE(HAVE_CYRUS_SASL,1,[define if you have Cyrus SASL])
		SASL_LIBS="$ol_link_sasl"
		if test $ol_enable_spasswd != no ; then
			ol_link_spasswd=yes
		fi

		ac_save_LIBS="$LIBS"
		LIBS="$LIBS $ol_link_sasl"
		AC_CHECK_FUNC(sasl_version, [AC_DEFINE(HAVE_SASL_VERSION,1,
			[define if your SASL library has sasl_version()])])
		LIBS="$ac_save_LIBS"

		WITH_SASL=yes
	fi

else
	AC_MSG_WARN([SASL authentication not supported!])
	if test $ol_link_tls = no ; then
		AC_MSG_WARN([Strong authentication not supported!])
	fi
fi

dnl ----------------------------------------------------------------
dnl Check for entropy sources
if test $cross_compiling != yes && test "$ac_cv_mingw32" != yes ; then
	dev=no
	if test -r /dev/urandom ; then
		dev="/dev/urandom";
	elif test -r /idev/urandom ; then
		dev="/idev/urandom";
	elif test -r /dev/srandom ; then
		dev="/dev/srandom";
	elif test -r /dev/random ; then
		dev="/dev/random";
	elif test -r /idev/random ; then
		dev="/idev/random";
	fi

	if test $dev != no ; then
		AC_DEFINE_UNQUOTED(URANDOM_DEVICE,"$dev",[set to urandom device])
	fi
fi

dnl ----------------------------------------------------------------
dnl
dnl Check for fetch URL support
dnl		should be extended to support other fetch URL APIs
dnl
ol_link_fetch=no
if test $ol_with_fetch != no ; then
	OL_LIB_FETCH

	if test $ol_cv_lib_fetch != no ; then
		LUTIL_LIBS="$LUTIL_LIBS $ol_link_fetch"
		ol_link_fetch=freebsd

	elif test $ol_with_fetch != auto ; then
		AC_MSG_ERROR(no suitable API for --with-fetch=$ol_with_fetch)
	fi 
fi

dnl ----------------------------------------------------------------
dnl FreeBSD (and others) have crypt(3) in -lcrypt
if test $ol_enable_crypt != no ; then
	save_LIBS="$LIBS"
	LIBS="$TLS_LIBS $LIBS"

	AC_CHECK_FUNC(crypt, [have_crypt=yes], [
		LIBS="$save_LIBS"
		AC_CHECK_LIB(crypt, crypt, [LUTIL_LIBS="$LUTIL_LIBS -lcrypt"
			have_crypt=yes], [have_crypt=no])])

	LIBS="$save_LIBS"

	if test $have_crypt = yes ; then
		AC_DEFINE(HAVE_CRYPT,1, [define if crypt(3) is available])
	else
		AC_MSG_WARN([could not find crypt])
		if test $ol_enable_crypt = yes ; then
			AC_MSG_ERROR([could not find crypt, select appropriate options or disable])
		fi

		AC_MSG_WARN([disabling crypt support])
		ol_enable_crypt=no
	fi
fi

dnl ----------------------------------------------------------------
dnl FreeBSD (and others) have setproctitle(3) in -lutil
if test $ol_enable_proctitle != no ; then
	AC_CHECK_FUNC(setproctitle,	[have_setproctitle=yes], [
		AC_CHECK_LIB(util, setproctitle,
			[have_setproctitle=yes
			LUTIL_LIBS="$LUTIL_LIBS -lutil"],
			[have_setproctitle=no
			AC_LIBOBJ(setproctitle)
			LIBSRCS="$LIBSRCS setproctitle.c"])])

	if test $have_setproctitle = yes ; then
		AC_DEFINE(HAVE_SETPROCTITLE,1,
			[define if setproctitle(3) is available])
	fi
fi

dnl ----------------------------------------------------------------
if test $ol_enable_slp != no ; then
	AC_CHECK_HEADERS( slp.h )

	if test $ac_cv_header_slp_h = yes ; then
		AC_CHECK_LIB(slp, SLPOpen, [have_slp=yes], [have_slp=no])
		if test $have_slp = yes ; then
			AC_DEFINE(HAVE_SLP, 1, [define if you have -lslp])
			SLAPD_SLP_LIBS=-lslp
		fi

	elif test $ol_enable_slp = yes ; then
		AC_MSG_ERROR([SLP not found])
	fi
fi

dnl ----------------------------------------------------------------
dnl Checks for typedefs, structures, and compiler characteristics.

AC_CHECK_TYPE(mode_t, int)
AC_CHECK_TYPE(off_t, long)
AC_CHECK_TYPE(pid_t, int)
AC_CHECK_TYPE(ssize_t, [signed int])
AC_CHECK_TYPE(caddr_t,	[char *])
AC_CHECK_TYPE(size_t, unsigned)

AC_CHECK_TYPES([long long])
AC_CHECK_TYPES([ptrdiff_t])


AC_CHECK_TYPE([socklen_t],,, [$ac_includes_default
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif])

dnl socklen_t-like type in accept(), default socklen_t or int:
dnl - The OS might define socklen_t without using it.  POSIX moved from
dnl   int to size_t to socklen_t, hoping to stay at a 32-bit type, and
dnl   HP-UX now has selectors for what to use.
dnl - On Solaris 2.8 the prototype has void *len, but the default is OK.
AC_MSG_CHECKING([the type of arg 3 to accept()])
AC_CACHE_VAL(ol_cv_type_ber_socklen_t, [
	set socklen_t int unsigned "unsigned long" long size_t
	test "$ac_cv_type_socklen_t" = yes || shift
	ol_cv_type_ber_socklen_t=$1 guessing="guessing "
	for lentype in "$@" ; do for addrtype in "struct sockaddr" void ; do
		AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_includes_default
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
extern int accept(int s, $addrtype *ap, $lentype *lp);
], [
accept(0, (struct sockaddr *) 0, ($lentype *) 0);
])], [ol_cv_type_ber_socklen_t=$lentype guessing= ; break 2])
	done ; done])
AC_MSG_RESULT([$guessing$ol_cv_type_ber_socklen_t *])
AC_DEFINE_UNQUOTED(ber_socklen_t, $ol_cv_type_ber_socklen_t,
	[Define to the type of arg 3 for `accept'.])

dnl Modules should use ber_socklen_t, not socklen_t.  Define socklen_t
dnl for the time being anyway, for backwards compatibility.
if test "$ac_cv_type_socklen_t" != yes; then
	AC_DEFINE_UNQUOTED([socklen_t], [$ol_cv_type_ber_socklen_t],
		[Define like ber_socklen_t if <sys/socket.h> does not define.])
fi


AC_TYPE_SIGNAL

AC_CHECK_TYPE([sig_atomic_t],,
	[AC_DEFINE_UNQUOTED([sig_atomic_t], [int],
		[Define to `int' if <signal.h> does not define.])],
	[$ac_includes_default
#include <signal.h>
	])

AC_TYPE_UID_T

AC_HEADER_TIME
AC_STRUCT_TM
AC_CHECK_MEMBERS([struct stat.st_blksize])
AC_CHECK_MEMBERS([struct passwd.pw_gecos],,,[$ac_includes_default
#include <pwd.h>])
AC_CHECK_MEMBERS([struct passwd.pw_passwd],,,[$ac_includes_default
#include <pwd.h>])

OL_C_UPPER_LOWER
AC_C_CONST
OL_C_VOLATILE

if test $cross_compiling = yes ; then
	AC_MSG_WARN([Crossing compiling... all bets are off!])
	AC_DEFINE(CROSS_COMPILING, 1, [define if cross compiling])
else
	AC_C_BIGENDIAN
fi

AC_CHECK_SIZEOF(short) 
AC_CHECK_SIZEOF(int) 
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(wchar_t)

if test "$ac_cv_sizeof_int" -lt 4 ; then
	AC_MSG_WARN([OpenLDAP requires 'int' to be 32 bits or greater.])

	AC_DEFINE(LBER_INT_T,long,[define to 32-bit or greater integer type])
else
	AC_DEFINE(LBER_INT_T,int,[define to 32-bit or greater integer type])
fi

AC_DEFINE(LBER_LEN_T,long,[define to large integer type])
AC_DEFINE(LBER_SOCKET_T,int,[define to socket descriptor type])
AC_DEFINE(LBER_TAG_T,long,[define to large integer type])

dnl ----------------------------------------------------------------
dnl Check for multiple precision support
if test $ol_with_mp = longlong || test $ol_with_mp = auto ; then
	if test $ac_cv_sizeof_long_long -gt 4 ; then
		ol_with_mp=longlong
		AC_DEFINE(USE_MP_LONG_LONG,1,[define to use 'long long' for MP])
	elif test $ol_with_mp = longlong ; then
		AC_MSG_ERROR([long long unusable for multiple precision])
	fi
fi
if test $ol_with_mp = long || test $ol_with_mp = auto ; then
	if test $ac_cv_sizeof_long -gt 4 ; then
		ol_with_mp=long
		AC_DEFINE(USE_MP_LONG,1,[define to use 'long' for MP])
	elif test $ol_with_mp = long ; then
		AC_MSG_ERROR([long unusable for multiple precision])
	fi
fi
if test $ol_with_mp = bignum || test $ol_with_mp = auto ; then
	AC_CHECK_HEADERS(openssl/bn.h)
	AC_CHECK_HEADERS(openssl/crypto.h)
	if test "$ac_cv_header_openssl_bn_h" = "yes" &&
		test "$ac_cv_header_openssl_crypto_h" = "yes" &&
		test "$ol_with_tls" = "found" ; then
		ol_with_mp=bignum
		AC_DEFINE(USE_MP_BIGNUM,1,[define to use OpenSSL BIGNUM for MP])
	elif test $ol_with_mp = bignum ; then
		AC_MSG_ERROR([bignum not available])
	fi
fi
if test $ol_with_mp = gmp || test $ol_with_mp = auto ; then
	AC_CHECK_HEADERS(gmp.h)
	AC_CHECK_LIB(gmp, __gmpz_add_ui)
	if test $ac_cv_header_gmp_h = yes && test $ac_cv_lib_gmp___gmpz_add_ui = yes ; then
		AC_DEFINE(USE_MP_GMP,1,[define to use GMP for MP])
		ol_with_mp=gmp
	elif test $ol_with_mp = gmp ; then
		AC_MSG_ERROR([gmp not available])
	fi
fi
if test $ol_with_mp = auto ; then
	ol_with_mp=no
fi

dnl ----------------------------------------------------------------
dnl Checks for library functions.
AC_FUNC_MEMCMP

if test $ac_cv_func_memcmp_working = no ; then
	AC_DEFINE(NEED_MEMCMP_REPLACEMENT,1,
		[define if memcmp is not 8-bit clean or is otherwise broken])
fi

AC_FUNC_STRFTIME

OL_FUNC_INET_ATON

dnl Check for NT specific routines
AC_CHECK_FUNC(_spawnlp, AC_DEFINE(HAVE_SPAWNLP,1,[if you have spawnlp()]))

AC_CHECK_FUNC(_snprintf, [ac_cv_func_snprintf=yes
	AC_DEFINE(snprintf, _snprintf, [define to snprintf routine])
])

AC_CHECK_FUNC(_vsnprintf, [ac_cv_func_vsnprintf=yes
	AC_DEFINE(vsnprintf, _vsnprintf, [define to vsnprintf routine])
])

AC_FUNC_VPRINTF

if test $ac_cv_func_vprintf = yes ; then
	dnl check for vsnprintf
	AC_CHECK_FUNCS(snprintf vsnprintf)
fi

AC_CHECK_FUNCS(			\
	bcopy			\
	closesocket		\
	chroot			\
	endgrent		\
	endpwent		\
	fcntl			\
	flock			\
	fstat			\
	getdtablesize		\
	getgrgid		\
	gethostname		\
	getpass			\
	getpassphrase		\
	getpwuid		\
	getpwnam		\
	getspnam		\
	gettimeofday		\
	initgroups		\
	inet_ntoa_b		\
	ioctl			\
	lockf			\
	memcpy			\
	memmove			\
	memrchr			\
	mkstemp			\
	mktemp			\
	pipe			\
	read			\
	recv			\
	recvfrom		\
	setpwfile		\
	setgid			\
	setegid			\
	setsid			\
	setuid			\
	seteuid			\
	signal			\
	strdup			\
	strpbrk			\
	strrchr			\
	strsep			\
	strstr			\
	strtol			\
	strtoul			\
	strtoq			\
	strtouq			\
	strtoll			\
	strspn			\
	sysconf			\
	waitpid			\
	wait4			\
	write			\
	send			\
	sendmsg			\
	sendto			\
)

dnl We actually may need to replace more than this.
AC_REPLACE_FUNCS(getopt getpeereid)

if test "$ac_cv_func_getopt" != yes; then
	LIBSRCS="$LIBSRCS getopt.c"
fi

if test "$ac_cv_func_getpeereid" != yes; then
	AC_CHECK_FUNCS( getpeerucred )
	if test "$ac_cv_func_getpeerucred" != yes ; then
		AC_CHECK_MEMBERS([struct msghdr.msg_accrightslen],,,
			[$ac_includes_default
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif])
		if test "$ac_cv_member_struct_msghdr_msg_accrightslen" != yes; then
			AC_CHECK_MEMBERS([struct msghdr.msg_control],,,
				[$ac_includes_default
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif])
		fi
		AC_CHECK_MEMBERS([struct stat.st_fstype, struct stat.st_vfstype])
		if test "$ac_cv_member_struct_stat_st_fstype" = yes; then
			AC_COMPILE_IFELSE([struct stat st; char *ptr=st.st_fstype;],
				AC_DEFINE([HAVE_STRUCT_STAT_ST_FSTYPE_CHAR],1,[define to 1 if st_fstype is char *]),
				AC_DEFINE([HAVE_STRUCT_STAT_ST_FSTYPE_INT],1,[define to 1 if st_fstype is int]))
		fi
	fi
	LIBSRCS="$LIBSRCS getpeereid.c"
fi

if test "$ac_cv_func_snprintf" != yes ||
   test "$ac_cv_func_vsnprintf" != yes; then
	if test "$ac_cv_func_snprintf" != yes; then
		AC_DEFINE(snprintf, ber_pvt_snprintf, [define to snprintf routine])
	fi
	if test "$ac_cv_func_vsnprintf" != yes; then
		AC_DEFINE(vsnprintf, ber_pvt_vsnprintf, [define to snprintf routine])
	fi
fi

dnl ----------------------------------------------------------------
dnl Sort out defines

if test "$ol_enable_slapi" != no ; then
	dnl This check is done also if --enable-modules is used;
	dnl it is duplicated here, 'cause it'd be cached anyway
	AC_CHECK_HEADERS(ltdl.h)

	if test $ac_cv_header_ltdl_h != yes ; then
		AC_MSG_ERROR([could not locate <ltdl.h>])
	fi
	AC_CHECK_LIB(ltdl, lt_dlinit, [
		SLAPI_LIBS=-lltdl
		LIBSLAPI=libslapi.a
		LIBSLAPITOOLS=../libslapi.a
		AC_DEFINE(HAVE_LIBLTDL,1,[define if you have libtool -ltdl])
	],[AC_MSG_ERROR([could not locate libtool -lltdl])])

	AC_DEFINE(LDAP_SLAPI,1, [define this to add SLAPI code])
fi

if test "$ol_enable_debug" != no ; then
	if test "$ol_enable_debug" = traditional; then
		AC_DEFINE(OLD_DEBUG,1,
			[define to use the original debug style])
	fi
	AC_DEFINE(LDAP_DEBUG,1,
		[define this to add debugging code])
fi
if test "$ol_enable_syslog" = yes ; then
	AC_DEFINE(LDAP_SYSLOG,1,
		[define this to add syslog code])
fi
if test "$ol_enable_proctitle" != no ; then
	AC_DEFINE(LDAP_PROCTITLE,1,
		[define this for LDAP process title support])
fi
if test "$ol_enable_referrals" != no ; then
	AC_DEFINE(LDAP_API_FEATURE_X_OPENLDAP_V2_REFERRALS,LDAP_VENDOR_VERSION,
		[define to LDAP VENDOR VERSION])
fi
if test "$ol_enable_local" != no; then
	AC_DEFINE(LDAP_PF_LOCAL,1,[define to support PF_LOCAL])
fi
if test "$ol_link_ipv6" != no; then
	AC_DEFINE(LDAP_PF_INET6,1,[define to support PF_INET6])
fi
if test "$ol_enable_cleartext" != no ; then
	AC_DEFINE(SLAPD_CLEARTEXT,1,[define to support cleartext passwords])
fi
if test "$ol_enable_crypt" != no ; then
	AC_DEFINE(SLAPD_CRYPT,1,[define to support crypt(3) passwords])
fi
if test "$ol_link_spasswd" != no ; then
	AC_DEFINE(SLAPD_SPASSWD,1,[define to support SASL passwords])
fi
if test "$ol_enable_rlookups" != no ; then
	AC_DEFINE(SLAPD_RLOOKUPS,1,[define to support reverse lookups])
fi
if test "$ol_enable_aci" != no ; then
	if test $ol_enable_dynacl = no ; then
		ol_enable_dynacl=yes
		AC_MSG_WARN([ACIs need dynacl])
	fi
	if test "$ol_enable_aci" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		dnl remove this after moving servers/slapd/aci.c in contrib/slapd-modules/acl
		AC_MSG_ERROR([ACI build as dynamic module not supported (yet)])
	else 
		MFLAG=SLAPD_MOD_STATIC
	fi
	WITH_ACI_ENABLED=$ol_enable_aci
	AC_DEFINE_UNQUOTED(SLAPD_ACI_ENABLED,$MFLAG,[define to support per-object ACIs])
else
	WITH_ACI_ENABLED=no
fi
if test "$ol_enable_dynacl" != no ; then
	AC_DEFINE(SLAP_DYNACL,1,[define to support run-time loadable ACL])
fi

if test "$ol_link_modules" != no ; then
	AC_DEFINE(SLAPD_MODULES,1,[define to support modules])
	BUILD_SLAPD=yes
	SLAPD_MODULES_LDFLAGS="-dlopen self"
fi

AC_DEFINE(SLAPD_MOD_STATIC,1,[statically linked module])
AC_DEFINE(SLAPD_MOD_DYNAMIC,2,[dynamically linked module])

dnl back-monitor goes first (well, after back-config)
if test "$ol_enable_monitor" != no ; then
	BUILD_SLAPD=yes
	BUILD_MONITOR=$ol_enable_monitor
	if test "$ol_enable_monitor" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-monitor"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-monitor"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_MONITOR,$MFLAG,[define to support cn=Monitor backend])
fi

if test "$ol_enable_bdb" != no ; then
	BUILD_SLAPD=yes
	BUILD_BDB=$ol_enable_bdb
	if test "$ol_enable_bdb" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-bdb"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-bdb"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_BDB,$MFLAG,[define to support BDB backend])
fi

if test "$ol_enable_dnssrv" != no ; then
	BUILD_SLAPD=yes
	BUILD_DNSSRV=$ol_enable_dnssrv
	if test "$ol_enable_dnssrv" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-dnssrv"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-dnssrv"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_DNSSRV,$MFLAG,[define to support DNS SRV backend])
fi

if test "$ol_enable_hdb" != no ; then
	BUILD_SLAPD=yes
	BUILD_HDB=$ol_enable_hdb
	if test "$ol_enable_hdb" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-hdb"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-hdb"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_HDB,$MFLAG,[define to support HDB backend])
fi

if test "$ol_enable_ldap" != no ; then
	BUILD_SLAPD=yes
	BUILD_LDAP=$ol_enable_ldap
	if test "$ol_enable_ldap" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-ldap"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-ldap"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_LDAP,$MFLAG,[define to support LDAP backend])
fi

if test "$ol_enable_meta" != no ; then
	BUILD_SLAPD=yes
	BUILD_META=$ol_enable_meta
	BUILD_REWRITE=yes
	if test "$ol_enable_meta" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-meta"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-meta"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_META,$MFLAG,[define to support LDAP Metadirectory backend])
fi

if test "$ol_enable_null" != no ; then
	BUILD_SLAPD=yes
	BUILD_NULL=$ol_enable_null
	if test "$ol_enable_null" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-null"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-null"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_NULL,$MFLAG,[define to support NULL backend])
fi

if test "$ol_enable_passwd" != no ; then
	BUILD_SLAPD=yes
	BUILD_PASSWD=$ol_enable_passwd
	if test "$ol_enable_passwd" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-passwd"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-passwd"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_PASSWD,$MFLAG,[define to support PASSWD backend])
fi

if test "$ol_link_perl" != no ; then
	BUILD_SLAPD=yes
	BUILD_PERL=$ol_enable_perl
	if test "$ol_enable_perl" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-perl"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-perl"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_PERL,$MFLAG,[define to support PERL backend])
fi

if test "$ol_enable_relay" != no ; then
	BUILD_SLAPD=yes
	BUILD_RELAY=$ol_enable_relay
	if test "$ol_enable_relay" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-relay"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-relay"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_RELAY,$MFLAG,[define to support relay backend])
fi

if test "$ol_enable_shell" != no ; then
	if test "$ol_link_threads" != no ; then
		AC_MSG_WARN([Use of --without-threads is recommended with back-shell])
	fi
	BUILD_SLAPD=yes
	BUILD_SHELL=$ol_enable_shell
	if test "$ol_enable_shell" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-shell"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-shell"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_SHELL,$MFLAG,[define to support SHELL backend])
fi

if test "$ol_enable_sock" != no ; then
	BUILD_SLAPD=yes
	BUILD_SOCK=$ol_enable_sock
	if test "$ol_enable_sock" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-sock"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-sock"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_SOCK,$MFLAG,[define to support SOCK backend])
fi

if test "$ol_link_sql" != no ; then
	BUILD_SLAPD=yes
	BUILD_SQL=$ol_enable_sql
	if test "$ol_enable_sql" = mod; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-sql"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-sql"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_SQL,$MFLAG,[define to support SQL backend])
fi

if test "$ol_enable_accesslog" != no ; then
	BUILD_ACCESSLOG=$ol_enable_accesslog
	if test "$ol_enable_accesslog" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS accesslog.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS accesslog.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_ACCESSLOG,$MFLAG,[define for In-Directory Access Logging overlay])
fi

if test "$ol_enable_auditlog" != no ; then
	BUILD_AUDITLOG=$ol_enable_auditlog
	if test "$ol_enable_auditlog" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS auditlog.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS auditlog.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_AUDITLOG,$MFLAG,[define for Audit Logging overlay])
fi

if test "$ol_enable_constraint" != no ; then
	BUILD_CONSTRAINT=$ol_enable_constraint
	if test "$ol_enable_constraint" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS constraint.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS constraint.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_CONSTRAINT,$MFLAG,[define for Attribute Constraint overlay])
fi

if test "$ol_enable_dds" != no ; then
	BUILD_DDS=$ol_enable_dds
	if test "$ol_enable_dds" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS dds.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS dds.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_DDS,$MFLAG,[define for Dynamic Directory Services overlay])
fi

if test "$ol_enable_dyngroup" != no ; then
	BUILD_DYNGROUP=$ol_enable_dyngroup
	if test "$ol_enable_dyngroup" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS dyngroup.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS dyngroup.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_DYNGROUP,$MFLAG,[define for Dynamic Group overlay])
fi

if test "$ol_enable_dynlist" != no ; then
	BUILD_DYNLIST=$ol_enable_dynlist
	if test "$ol_enable_dynlist" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS dynlist.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS dynlist.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_DYNLIST,$MFLAG,[define for Dynamic List overlay])
fi

if test "$ol_enable_memberof" != no ; then
	BUILD_MEMBEROF=$ol_enable_memberof
	if test "$ol_enable_memberof" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS memberof.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS memberof.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_MEMBEROF,$MFLAG,[define for Reverse Group Membership overlay])
fi

if test "$ol_enable_ppolicy" != no ; then
	BUILD_PPOLICY=$ol_enable_ppolicy
	if test "$ol_enable_ppolicy" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS ppolicy.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS ppolicy.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_PPOLICY,$MFLAG,[define for Password Policy overlay])
fi

if test "$ol_enable_proxycache" != no ; then
	BUILD_PROXYCACHE=$ol_enable_proxycache
	if test "$ol_enable_proxycache" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS pcache.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS pcache.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_PROXYCACHE,$MFLAG,[define for Proxy Cache overlay])
fi

if test "$ol_enable_refint" != no ; then
	BUILD_REFINT=$ol_enable_refint
	if test "$ol_enable_refint" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS refint.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS refint.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_REFINT,$MFLAG,[define for Referential Integrity overlay])
fi

if test "$ol_enable_retcode" != no ; then
	BUILD_RETCODE=$ol_enable_retcode
	if test "$ol_enable_retcode" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS retcode.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS retcode.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_RETCODE,$MFLAG,[define for Referential Integrity overlay])
fi

if test "$ol_enable_rwm" != no ; then
	BUILD_REWRITE=yes
	BUILD_RWM=$ol_enable_rwm
	if test "$ol_enable_rwm" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS rwm.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS rwm_x.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_RWM,$MFLAG,[define for Rewrite/Remap overlay])
fi

if test "$ol_enable_seqmod" != no ; then
	BUILD_SEQMOD=$ol_enable_seqmod
	if test "$ol_enable_seqmod" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS seqmod.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS seqmod.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_SEQMOD,$MFLAG,[define for Sequential Modify overlay])
fi

if test "$ol_enable_syncprov" != no ; then
	BUILD_SYNCPROV=$ol_enable_syncprov
	if test "$ol_enable_syncprov" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS syncprov.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS syncprov.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_SYNCPROV,$MFLAG,[define for Syncrepl Provider overlay])
fi

if test "$ol_enable_translucent" != no ; then
	BUILD_TRANSLUCENT=$ol_enable_translucent
	if test "$ol_enable_translucent" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS translucent.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS translucent.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_TRANSLUCENT,$MFLAG,[define for Translucent Proxy overlay])
fi

if test "$ol_enable_unique" != no ; then
	BUILD_UNIQUE=$ol_enable_unique
	if test "$ol_enable_unique" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS unique.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS unique.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_UNIQUE,$MFLAG,[define for Attribute Uniqueness overlay])
fi

if test "$ol_enable_valsort" != no ; then
	BUILD_VALSORT=$ol_enable_valsort
	if test "$ol_enable_valsort" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS valsort.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS valsort.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_VALSORT,$MFLAG,[define for Value Sorting overlay])
fi

if test "$ol_enable_rewrite" != no ; then
	AC_DEFINE(ENABLE_REWRITE,1,[define to enable rewriting in back-ldap and back-meta])
	BUILD_REWRITE=yes
fi

if test "$ol_enable_slapi" != no ; then
	AC_DEFINE(ENABLE_SLAPI,1,[define to enable slapi library])
	BUILD_SLAPI=yes
	SLAPD_SLAPI_DEPEND=libslapi.a
fi

dnl ----------------------------------------------------------------

dnl
dnl For Windows build, we don't want to include -dlopen flags.
dnl They hurt more than they help.
dnl

if test "$ac_cv_mingw32" = yes ; then
	PLAT=NT
	SLAPD_MODULES_LDFLAGS=
else
	PLAT=UNIX
fi

AC_SUBST(LIBSRCS)
AC_SUBST(PLAT)
AC_SUBST(WITH_SASL)
AC_SUBST(WITH_TLS)
AC_SUBST(WITH_MODULES_ENABLED)
AC_SUBST(WITH_ACI_ENABLED)
AC_SUBST(BUILD_THREAD)
AC_SUBST(BUILD_LIBS_DYNAMIC)

AC_SUBST(BUILD_SLAPD)
dnl slapi
  AC_SUBST(BUILD_SLAPI)
  AC_SUBST(SLAPD_SLAPI_DEPEND)
dnl backends
  AC_SUBST(BUILD_BDB)
  AC_SUBST(BUILD_DNSSRV)
  AC_SUBST(BUILD_HDB)
  AC_SUBST(BUILD_LDAP)
  AC_SUBST(BUILD_META)
  AC_SUBST(BUILD_MONITOR)
  AC_SUBST(BUILD_NULL)
  AC_SUBST(BUILD_PASSWD)
  AC_SUBST(BUILD_RELAY)
  AC_SUBST(BUILD_PERL)
  AC_SUBST(BUILD_SHELL)
  AC_SUBST(BUILD_SOCK)
  AC_SUBST(BUILD_SQL)
dnl overlays
  AC_SUBST(BUILD_ACCESSLOG)
  AC_SUBST(BUILD_AUDITLOG)
  AC_SUBST(BUILD_CONSTRAINT)
  AC_SUBST(BUILD_DDS)
  AC_SUBST(BUILD_DENYOP)
  AC_SUBST(BUILD_DYNGROUP)
  AC_SUBST(BUILD_DYNLIST)
  AC_SUBST(BUILD_LASTMOD)
  AC_SUBST(BUILD_MEMBEROF)
  AC_SUBST(BUILD_PPOLICY)
  AC_SUBST(BUILD_PROXYCACHE)
  AC_SUBST(BUILD_REFINT)
  AC_SUBST(BUILD_RETCODE)
  AC_SUBST(BUILD_RWM)
  AC_SUBST(BUILD_SEQMOD)
  AC_SUBST(BUILD_SYNCPROV)
  AC_SUBST(BUILD_TRANSLUCENT)
  AC_SUBST(BUILD_UNIQUE)
  AC_SUBST(BUILD_VALSORT)

AC_SUBST(LDAP_LIBS)
AC_SUBST(SLAPD_LIBS)
AC_SUBST(BDB_LIBS)
AC_SUBST(LTHREAD_LIBS)
AC_SUBST(LUTIL_LIBS)
AC_SUBST(WRAP_LIBS)

AC_SUBST(SLAPD_MODULES_CPPFLAGS)
AC_SUBST(SLAPD_MODULES_LDFLAGS)

AC_SUBST(SLAPD_NO_STATIC)
AC_SUBST(SLAPD_STATIC_BACKENDS)
AC_SUBST(SLAPD_DYNAMIC_BACKENDS)
AC_SUBST(SLAPD_STATIC_OVERLAYS)
AC_SUBST(SLAPD_DYNAMIC_OVERLAYS)

AC_SUBST(PERL_CPPFLAGS)
AC_SUBST(SLAPD_PERL_LDFLAGS)
AC_SUBST(MOD_PERL_LDFLAGS)

AC_SUBST(KRB4_LIBS)
AC_SUBST(KRB5_LIBS)
AC_SUBST(SASL_LIBS)
AC_SUBST(TLS_LIBS)
AC_SUBST(MODULES_LIBS)
AC_SUBST(SLAPI_LIBS)
AC_SUBST(LIBSLAPI)
AC_SUBST(LIBSLAPITOOLS)
AC_SUBST(AUTH_LIBS)
AC_SUBST(ICU_LIBS)

AC_SUBST(SLAPD_SLP_LIBS)
AC_SUBST(SLAPD_GMP_LIBS)

AC_SUBST(SLAPD_SQL_LDFLAGS)
AC_SUBST(SLAPD_SQL_LIBS)
AC_SUBST(SLAPD_SQL_INCLUDES)

AC_CONFIG_COMMANDS([default-1],[[
## Copied from glib configure.in
## Generate `ndsconfig.h' in two cases
## 1. `config.status' is run either explicitly, or via configure.
##     Esp. not when it is run in `Makefile' to generate makefiles and
##     config.h
## 2. CONFIG_OTHER is set explicitly
##
## Case 1 is difficult.  We know that `automake' sets one of
## CONFIG_FILES or CONFIG_HEADERS to empty.  This heuristic works
## only when _au_m4_changequote([,])AM_CONFIG_HEADER is set, however.

if test -n "${CONFIG_FILES}" && test -n "${CONFIG_HEADERS}"; then
  # Both CONFIG_FILES and CONFIG_HEADERS are non-empty ==> Case 1
  CONFIG_OTHER=${CONFIG_OTHER:-ndsconfig.h}
fi
case "$CONFIG_OTHER" in
*ndsconfig.h*)
        echo creating ndsconfig.h
        outfile=ndsconfig.h-tmp
        cat > $outfile <<\_______EOF
/* ndsconfig.h
 *
 * This is a generated file.  Please modify `configure.in'
 */

#ifndef SSLCONFIG_H
#define SSLCONFIG_H

/* C linkage definitions */
#ifdef __cplusplus
# define __BEGIN_CDECLS extern "C" {
# define __END_CDECLS }
#else
# define __BEGIN_CDECLS /* empty */
# define __END_CDECLS /* empty */
#endif

__BEGIN_CDECLS

_______EOF

        if test -r ndsconfig-sysdefs.h; then
          cat ndsconfig-sysdefs.h >>$outfile
        fi

        cat >>$outfile <<_______EOF

/* NDS Platform Definitions
 */

#if !defined(DS_FOR_UNIX)
#define DS_FOR_UNIX
#endif
#if !defined(SAL_UNIX)
#define SAL_UNIX
#endif
#define $nds_byte_order
#define $nds_alignment

__END_CDECLS

#if defined(_CONFIG_H) && defined(inline) && defined(__cplusplus)
#undef inline
#endif
#else /* SSLCONFIG_H */
#if defined(inline) && defined (__cplusplus)
#undef inline
#endif  /* inline       */
#endif  /* SSLCONFIG_H  */
_______EOF
        if cmp -s $outfile ndsconfig.h; then
          echo ndsconfig.h is unchanged
          rm -f $outfile
        else
          mv $outfile ndsconfig.h
        fi ;;
esac
]],[[

case xyes in
x$ac_cv_c_bigendian)
    nds_byte_order="LO_HI_MACH_TYPE 0"
    nds_alignment="STRICT_ALIGNMENT 1"
    ;;
*)
    nds_byte_order="LO_HI_MACH_TYPE 1"
    if echo $host_cpu | grep "alpha" >/dev/null 2>&1; then
        nds_alignment="STRICT_ALIGNMENT 1"
    else
        nds_alignment="STRICT_ALIGNMENT 0"
    fi
    ;;
esac

]])
dnl ----------------------------------------------------------------
dnl final help output
AC_ARG_WITH(xxinstall,[
See INSTALL file for further details.])

dnl ----------------------------------------------------------------
dnl final output
dnl

AC_CONFIG_FILES([\
Makefile:build/top.mk:Makefile.in:build/dir.mk \
include/Makefile:build/top.mk:include/Makefile.in \
libraries/Makefile:build/top.mk:libraries/Makefile.in:build/lib.mk:build/lib-shared.mk \
samples/Makefile:build/top.mk:samples/Makefile.in:build/dir.mk \
samples/extensions/Makefile:build/top.mk:samples/extensions/Makefile.in:build/rules.mk \
])

AC_CONFIG_COMMANDS([default],[[
date > stamp-h
if test "${ol_cv_mkdep}" = no; then
	echo '(Do not "make depend"; we do not know how to build dependencies)'
else
	echo 'Please run "make depend" to build dependencies'
fi
]],[[
STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS"
STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS"
]])
AC_OUTPUT