configure.in

		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
			LDBM_LIBS="$LDBM_LIBS $ol_cv_lib_db"
		fi
	fi
fi

if test $ol_enable_bdb != no -o $ol_enable_hdb != no; then
	if test $ol_link_ldbm != berkeley ; then
		AC_MSG_ERROR(BDB/HDB: BerkeleyDB not available)
	else
		OL_BDB_COMPAT

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

if test $ol_link_ldbm = no -a $ol_enable_ldbm_type = btree ; then
	AC_MSG_WARN([Could not find LDBM with BTREE support])
	ol_enable_ldbm_api=none
fi

if test $ol_enable_ldbm_api = auto -o $ol_enable_ldbm_api = mdbm ; then
	OL_MDBM

	if test $ol_cv_mdbm = yes ; then
		ol_link_ldbm=mdbm
		ol_enable_ldbm_api=mdbm
		if test $ol_cv_lib_mdbm != yes ; then
			LDBM_LIBS="$LDBM_LIBS $ol_cv_lib_mdbm"
		fi
	fi
fi

if test $ol_enable_ldbm_api = auto -o $ol_enable_ldbm_api = gdbm ; then
	OL_GDBM

	if test $ol_cv_gdbm = yes ; then
		ol_link_ldbm=gdbm
		ol_enable_ldbm_api=gdbm

		if test $ol_cv_lib_gdbm != yes ; then
			LDBM_LIBS="$LDBM_LIBS $ol_cv_lib_gdbm"
		fi
	fi
fi

if test $ol_enable_ldbm_api = ndbm ; then
	OL_NDBM

	if test $ol_cv_ndbm = yes ; then
		ol_link_ldbm=ndbm
		ol_enable_ldbm_api=ndbm

		if test $ol_cv_lib_ndbm != yes ; then
			LDBM_LIBS="$LDBM_LIBS $ol_cv_lib_ndbm"
		fi
	fi
fi

if test $ol_link_ldbm = no -a $ol_enable_ldbm != no ; then
	AC_MSG_ERROR([could not find suitable LDBM backend])
fi

if test $ol_enable_bdb = yes -o \
	$ol_enable_hdb = yes -o \
	$ol_enable_ldbm = yes ; then
	SLAPD_LIBS="$SLAPD_LIBS \$(LDBM_LIBS)"
fi

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

if test $ol_enable_dynamic = yes -a $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 -a $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"

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

	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
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 -o $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 -a "$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 ----------------------------------------------------------------
dnl Check for SLPv2 Compliant API Library
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 Check for multiple precision support
if test "$ol_with_multiple_precision" != "no" ; then
	ol_have_bignum=no
	ol_have_gmp=no

	AC_CHECK_HEADERS(openssl/bn.h bn.h)
	AC_CHECK_HEADERS(openssl/crypto.h crypto.h)
	AC_CHECK_HEADERS( gmp.h )

	if test "$ol_with_tls" = "found" ; then
		ol_have_bn_h=no
		ol_have_crypto_h=no

		if test "$ac_cv_header_openssl_bn_h" = "yes" \
				-o "$ac_cv_header_bn_h" = "yes" ; then
			ol_have_bn_h=yes
		fi

		if test "$ac_cv_header_openssl_crypto_h" = "yes" \
				-o "$ac_cv_header_crypto_h" = "yes" ; then
			ol_have_crypto_h=yes
		fi

		if test "$ol_have_bn_h" = "yes" \
				-a "$ol_have_crypto_h" = "yes" ; then
			ol_have_bignum=yes
		fi
	fi

	if test $ac_cv_header_gmp_h = yes ; then
		AC_CHECK_LIB(gmp, __gmpz_add_ui, [have_gmp=yes], [have_gmp=no])
		if test $have_gmp = yes ; then
			ol_have_gmp=yes
		fi
	fi

	AC_MSG_CHECKING([for multiple precision support])

	ol_mp_support="none"
	case "$ol_with_multiple_precision" in
	auto)
		dnl preferred sequence:
		dnl - OpenSSL's BIGNUM (if libssl is already linked)
		dnl - GNU's MP
		dnl - unsigned long
		if test "$ol_have_bignum" = "yes" ; then
			ol_mp_support="bignum"
		else
			if test "$ol_have_gmp" = "yes" ; then
				ol_mp_support="gmp"
			fi
		fi
		;;
	bignum)
		if test "$ol_have_bignum" != "yes" ; then
			AC_MSG_ERROR([OpenSSL's BIGNUM not available])
		fi
		ol_mp_support="bignum"
		;;
	gmp)
		if test "$ol_have_gmp" != "yes" ; then
			AC_MSG_ERROR([GMP not available])
		fi
		ol_mp_support="gmp"
		;;
	yes)
		if test "$ol_have_bignum" = "yes" ; then
			ol_mp_support="bignum"
		elif test "$ol_have_gmp" = "yes" ; then
			ol_mp_support="gmp"
		else
			AC_MSG_ERROR([not available])
		fi
		;;
	esac

	case "$ol_mp_support" in
	bignum)
		AC_DEFINE(HAVE_BIGNUM, 1,
			[define if you have SSLeay or OpenSSL's BIGNUM])
		;;
	gmp)
		AC_DEFINE(HAVE_GMP, 1, [define if you have -lgmp])
		SLAPD_GMP_LIBS=-lgmp
		;;
	none)
		;;
	esac

	AC_MSG_RESULT($ol_mp_support)
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_DEFINE_UNQUOTED([socklen_t], [int],
		[Define to `int' if <sys/socket.h> does not define.])],
	[$ac_includes_default
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
	])

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(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 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		\
	lockf			\
	memcpy			\
	memmove			\
	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			\
	usleep			\
	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_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
	LIBSRCS="$LIBSRCS getpeereid.c"
fi
if test "$ac_cv_func_snprintf" != yes -o "$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
	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_link_kbind" != no ; then
	AC_DEFINE(LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND,LDAP_VENDOR_VERSION,
		[define to LDAP VENDOR VERSION])
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_multimaster" != no ; then
	AC_DEFINE(SLAPD_MULTIMASTER,1,[define to support multimaster replication])
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
	AC_DEFINE(SLAPD_ACI_ENABLED,1,[define to support per-object ACIs])
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])

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_link_ldbm" != no -a $ol_enable_ldbm != no; then
	BUILD_SLAPD=yes
	BUILD_LDBM=$ol_enable_ldbm
	if test "$ol_enable_ldbm" = mod ; then
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-ldbm"
		MFLAG=SLAPD_MOD_DYNAMIC
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-ldbm"
		MFLAG=SLAPD_MOD_STATIC
	fi
	AC_DEFINE_UNQUOTED(SLAPD_LDBM,$MFLAG,[define to support LDBM 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_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_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_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_denyop" != no ; then
	BUILD_DENYOP=$ol_enable_denyop
	if test "$ol_enable_denyop" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS denyop.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS denyop.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_DENYOP,$MFLAG,[define for Dynamic Group 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_glue" != no ; then
	BUILD_GLUE=$ol_enable_glue
	if test "$ol_enable_glue" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS glue.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS glue.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_GLUE,$MFLAG,[define for Backend Glue overlay])
fi

if test "$ol_enable_lastmod" != no ; then
	BUILD_LASTMOD=$ol_enable_lastmod
	if test "$ol_enable_lastmod" = mod ; then
		MFLAG=SLAPD_MOD_DYNAMIC
		SLAPD_DYNAMIC_OVERLAYS="$SLAPD_DYNAMIC_OVERLAYS lastmod.la"
	else
		MFLAG=SLAPD_MOD_STATIC
		SLAPD_STATIC_OVERLAYS="$SLAPD_STATIC_OVERLAYS lastmod.o"
	fi
	AC_DEFINE_UNQUOTED(SLAPD_OVER_LASTMOD,$MFLAG,[define for Last Modification 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_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