configure.in

if test $ol_enable_bdb = yes -a $ol_link_ldbm != berkeley ; then
	AC_MSG_ERROR(BDB: BerkeleyDB not available)
elif test $ol_enable_bdb != no -a $ol_link_ldbm = berkeley ; then
	OL_BDB_COMPAT

	if test $ol_cv_bdb_compat = yes ; then
		ol_enable_bdb=yes
	elif test $ol_enable_bdb = yes ; then
		AC_MSG_ERROR(BDB: BerkeleyDB version incompatible)
	else
		ol_enable_bdb=no
	fi
fi
if test $ol_enable_hdb = yes -a $ol_link_ldbm != berkeley ; then
	AC_MSG_ERROR(HDB: BerkeleyDB not available)
fi

if test $ol_link_ldbm = no -a $ol_with_ldbm_type = btree ; then
	AC_MSG_WARN(Could not find LDBM with BTREE support)
	ol_with_ldbm_api=none
fi

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

	if test $ol_cv_mdbm = yes ; then
		ol_link_ldbm=mdbm
		ol_with_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_with_ldbm_api = auto -o $ol_with_ldbm_api = gdbm ; then
	OL_GDBM

	if test $ol_cv_gdbm = yes ; then
		ol_link_ldbm=gdbm
		ol_with_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_with_ldbm_api = ndbm ; then
	OL_NDBM

	if test $ol_cv_ndbm = yes ; then
		ol_link_ldbm=ndbm
		ol_with_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_WARN(could not find suitable LDBM backend)
	if test $ol_enable_ldbm = yes ; then
		AC_MSG_ERROR(select appropriate LDBM options or disable)
	fi

	AC_MSG_WARN(disabling LDBM)
	ol_enable_ldbm=no
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_TRY_LINK([
#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])],[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 dmalloc support (deprecated in favor of -DCSRIMALLOC support)
dnl if test $ol_enable_dmalloc != no ; then
dnl 	AC_CHECK_HEADERS(dmalloc.h)
dnl 	AC_CHECK_LIB(dmalloc, dmalloc_shutdown)
dnl 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])
	])

	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

	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
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 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"
	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
			LIBOBJS="$LIBOBJS setproctitle.o"
			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 Checks for typedefs, structures, and compiler characteristics.

dnl Checks for long long
AC_CACHE_CHECK([long long], ol_cv_type_long_long, [
	AC_TRY_COMPILE([], [long long x;],
		[ol_cv_type_long_long=yes],
		[ol_cv_type_long_long=no])])
if test $ol_cv_type_long_long = yes; then
	AC_DEFINE(HAVE_LONG_LONG, 1, [define if you have 'long long'])
fi

AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AM_TYPE_PTRDIFF_T
AC_TYPE_SIGNAL
AC_TYPE_SIZE_T

AC_CHECK_TYPE(ssize_t, [signed int])
AC_CHECK_TYPE(caddr_t,	[char *])

OL_TYPE_SOCKLEN_T
AC_STRUCT_ST_BLKSIZE
AC_HEADER_TIME
AC_STRUCT_TM
AC_TYPE_UID_T
OL_TYPE_SIG_ATOMIC_T

dnl AC_TYPE_GETGROUPS

OL_STRUCT_PASSWD_PW_GECOS
OL_STRUCT_PASSWD_PW_PASSWD

OL_C_UPPER_LOWER
AC_C_CONST
OL_C_VOLATILE

if test $cross_compiling = yes ; then
	AC_DEFINE(CROSS_COMPILING, 1, [define if cross compiling])
else
	AC_C_BIGENDIAN
fi

AC_COMPILE_CHECK_SIZEOF(short) 
AC_COMPILE_CHECK_SIZEOF(int) 
AC_COMPILE_CHECK_SIZEOF(long)

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)
else
	AC_DEFINE(LBER_INT_T,int)
fi

AC_DEFINE(LBER_LEN_T,long)
AC_DEFINE(LBER_SOCKET_T,int)
AC_DEFINE(LBER_TAG_T,long)

dnl ----------------------------------------------------------------
dnl Checks for library functions.
AC_FUNC_MEMCMP
dnl AM_FUNC_MKTIME dnl checks for sys/time.h and unistd.h
AC_FUNC_STRFTIME
dnl AM_FUNC_STRTOD

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			\
	sigaction		\
	signal			\
	sigset			\
	strdup			\
	strerror		\
	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
	OL_MSGHDR_MSG_ACCRIGHTS
	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 ----------------------------------------------------------------
# Check Configuration
OL_SYS_ERRLIST

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

if test "$ol_enable_slapi" != no ; then
	dnl This check is donel 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)
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)
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_kpasswd" != no ; then
	AC_DEFINE(SLAPD_KPASSWD,1,[define to support Kerberos 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
	AC_DEFINE(SLAPD_BDB,1,[define to support BDB backend])
	BUILD_SLAPD=yes
	BUILD_BDB=yes
	if test "$ol_with_bdb_module" != static ; then
		AC_DEFINE(SLAPD_BDB_DYNAMIC,1,
			[define to support dynamic BDB backend])
		BUILD_BDB=mod
		BUILD_BDB_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-bdb"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-bdb"
	fi
fi

if test "$ol_link_dnssrv" != no ; then
	AC_DEFINE(SLAPD_DNSSRV,1,[define to support DNS SRV backend])
	BUILD_SLAPD=yes
	BUILD_DNSSRV=yes
	if test "$ol_with_dnssrv_module" != static ; then
		AC_DEFINE(SLAPD_DNSSRV_DYNAMIC,1,
			[define to support dynamic DNS SRV backend])
		BUILD_DNSSRV=mod
		BUILD_DNSSRV_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-dnssrv"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-dnssrv"
	fi
fi

if test "$ol_enable_hdb" != no ; then
	AC_DEFINE(SLAPD_HDB,1,[define to support HDB backend])
	BUILD_SLAPD=yes
	BUILD_HDB=yes
	if test "$ol_with_hdb_module" != static ; then
		AC_DEFINE(SLAPD_HDB_DYNAMIC,1,
			[define to support dynamic HDB backend])
		BUILD_HDB=mod
		BUILD_HDB_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-hdb"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-hdb"
	fi
fi

if test "$ol_enable_ldap" != no ; then
	AC_DEFINE(SLAPD_LDAP,1,[define to support LDAP backend])
	BUILD_SLAPD=yes
	BUILD_LDAP=yes
	if test "$ol_with_ldap_module" != static ; then
		AC_DEFINE(SLAPD_LDAP_DYNAMIC,1,
			[define to support dynamic LDAP backend])
		BUILD_LDAP=mod
		BUILD_LDAP_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-ldap"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-ldap"
	fi
fi

if test "$ol_link_ldbm" != no -a $ol_enable_ldbm != no; then
	AC_DEFINE(SLAPD_LDBM,1,[define to support LDBM backend])
	BUILD_SLAPD=yes
	BUILD_LDBM=yes
	if test "$ol_with_ldbm_module" != static ; then
		AC_DEFINE(SLAPD_LDBM_DYNAMIC,1,
			[define to support dynamic LDBM backend])
		BUILD_LDBM=mod
		BUILD_LDBM_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-ldbm"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-ldbm"
	fi
fi

if test "$ol_enable_meta" != no ; then
	if test "$ol_enable_ldap" = no ; then
		AC_MSG_ERROR([need --enable-ldap to use --enable-meta])
	fi
	if test "$ol_enable_rewrite" = no ; then
		AC_MSG_ERROR([need --enable-rewrite to use --enable-meta])
	fi
	AC_DEFINE(SLAPD_META,1,[define to support LDAP Metadirectory backend])
	BUILD_SLAPD=yes
	BUILD_META=yes
	BUILD_REWRITE=yes
	if test "$ol_with_meta_module" != static ; then
		AC_DEFINE(SLAPD_META_DYNAMIC,1,
			[define to support dynamic LDAP Metadirectory backend])
		BUILD_META=mod
		BUILD_META_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-meta"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-meta"
	fi
fi

if test "$ol_enable_monitor" != no ; then
	AC_DEFINE(SLAPD_MONITOR,1,[define to support cn=Monitor backend])
	BUILD_SLAPD=yes
	BUILD_MONITOR=yes
	if test "$ol_with_monitor_module" != static ; then
		AC_DEFINE(SLAPD_MONITOR_DYNAMIC,1,
			[define to support dynamic cn=Monitor backend])
		BUILD_MONITOR=mod
		BUILD_MONITOR_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-monitor"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-monitor"
	fi
fi

if test "$ol_enable_null" != no ; then
	AC_DEFINE(SLAPD_NULL,1,[define to support NULL backend])
	BUILD_SLAPD=yes
	BUILD_NULL=yes
	if test "$ol_with_null_module" != static ; then
		AC_DEFINE(SLAPD_NULL_DYNAMIC,1,
			[define to support dynamic NULL backend])
		BUILD_NULL=mod
		BUILD_NULL_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-null"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-null"
	fi
fi

if test "$ol_enable_passwd" != no ; then
	AC_DEFINE(SLAPD_PASSWD,1,[define to support PASSWD backend])
	BUILD_SLAPD=yes
	BUILD_PASSWD=yes
	if test "$ol_with_passwd_module" != static ; then
		AC_DEFINE(SLAPD_PASSWD_DYNAMIC,1,
			[define to support dynamic PASSWD backend])
		BUILD_PASSWD=mod
		BUILD_PASSWD_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-passwd"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-passwd"
	fi
fi

if test "$ol_link_perl" != no ; then
	AC_DEFINE(SLAPD_PERL,1,[define to support PERL backend])
	BUILD_SLAPD=yes
	BUILD_PERL=yes
	if test "$ol_with_perl_module" != static ; then
		AC_DEFINE(SLAPD_PERL_DYNAMIC,1,
			[define to support dynamic PERL backend])
		BUILD_PERL=mod
		BUILD_PERL_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-perl"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-perl"
	fi
fi

if test "$ol_enable_shell" != no ; then
	if test "$ol_link_thread" != no ; then
		AC_MSG_WARN([Use of --without-threads is recommended with back-shell])
	fi
	AC_DEFINE(SLAPD_SHELL,1,[define to support SHELL backend])
	BUILD_SLAPD=yes
	BUILD_SHELL=yes
	if test "$ol_with_shell_module" != static ; then
		AC_DEFINE(SLAPD_SHELL_DYNAMIC,1,
			[define to support dynamic SHELL backend])
		BUILD_SHELL=mod
		BUILD_SHELL_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-shell"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-shell"
	fi
fi

if test "$ol_link_sql" != no ; then
	AC_DEFINE(SLAPD_SQL,1,[define to support SQL backend])
	BUILD_SLAPD=yes
	BUILD_SQL=yes
	if test "$ol_with_sql_module" != static; then
		AC_DEFINE(SLAPD_SQL_DYNAMIC,1,
			[define to support dynamic SQL backend])
		BUILD_SQL=mod
		BUILD_SQL_DYNAMIC=shared
		SLAPD_DYNAMIC_BACKENDS="$SLAPD_DYNAMIC_BACKENDS back-sql"
	else
		SLAPD_STATIC_BACKENDS="$SLAPD_STATIC_BACKENDS back-sql"
	fi
fi

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

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

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

if test "$ol_enable_slurpd" != no -a "$ol_link_threads" != no -a \
	$BUILD_SLAPD = yes ; then
	BUILD_SLURPD=yes
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

if test -z "$SLAPD_STATIC_BACKENDS"; then
	SLAPD_NO_STATIC='#'
else
	SLAPD_NO_STATIC=
fi

AC_SUBST(LIBSRCS)
AC_SUBST(PLAT)
AC_SUBST(WITH_TLS)
AC_SUBST(BUILD_LIBS_DYNAMIC)

AC_SUBST(BUILD_SLAPD)
  AC_SUBST(BUILD_SLAPI)
  AC_SUBST(SLAPD_SLAPI_DEPEND)
  AC_SUBST(BUILD_BDB)
  AC_SUBST(BUILD_DNSSRV)
  AC_SUBST(BUILD_HDB)
  AC_SUBST(BUILD_LDAP)
  AC_SUBST(BUILD_LDBM)
  AC_SUBST(BUILD_META)
  AC_SUBST(BUILD_MONITOR)
  AC_SUBST(BUILD_NULL)
  AC_SUBST(BUILD_PASSWD)
  AC_SUBST(BUILD_PERL)
  AC_SUBST(BUILD_SHELL)
  AC_SUBST(BUILD_SQL)
  AC_SUBST(BUILD_BDB_DYNAMIC)
  AC_SUBST(BUILD_DNSSRV_DYNAMIC)
  AC_SUBST(BUILD_HDB_DYNAMIC)
  AC_SUBST(BUILD_LDAP_DYNAMIC)
  AC_SUBST(BUILD_LDBM_DYNAMIC)
  AC_SUBST(BUILD_META_DYNAMIC)
  AC_SUBST(BUILD_MONITOR_DYNAMIC)
  AC_SUBST(BUILD_NULL_DYNAMIC)
  AC_SUBST(BUILD_PASSWD_DYNAMIC)
  AC_SUBST(BUILD_PERL_DYNAMIC)
  AC_SUBST(BUILD_SHELL_DYNAMIC)
  AC_SUBST(BUILD_SQL_DYNAMIC)
  AC_SUBST(BUILD_DYNGROUP)
  AC_SUBST(BUILD_PROXYCACHE)
  AC_SUBST(BUILD_RWM)
AC_SUBST(BUILD_SLURPD)

AC_SUBST(LDAP_LIBS)
AC_SUBST(SLAPD_LIBS)
AC_SUBST(SLURPD_LIBS)
AC_SUBST(LDBM_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_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(SLAPD_SLP_LIBS)

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

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

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

AC_OUTPUT( \
Makefile:build/top.mk:Makefile.in:build/dir.mk \
doc/Makefile:build/top.mk:doc/Makefile.in:build/dir.mk \
doc/man/Makefile:build/top.mk:doc/man/Makefile.in:build/dir.mk \
doc/man/man1/Makefile:build/top.mk:doc/man/man1/Makefile.in:build/man.mk \
doc/man/man3/Makefile:build/top.mk:doc/man/man3/Makefile.in:build/man.mk \
doc/man/man5/Makefile:build/top.mk:doc/man/man5/Makefile.in:build/man.mk \
doc/man/man8/Makefile:build/top.mk:doc/man/man8/Makefile.in:build/man.mk \
clients/Makefile:build/top.mk:clients/Makefile.in:build/dir.mk \
clients/tools/Makefile:build/top.mk:clients/tools/Makefile.in:build/rules.mk \
include/Makefile:build/top.mk:include/Makefile.in \
libraries/Makefile:build/top.mk:libraries/Makefile.in:build/dir.mk 	\
libraries/liblber/Makefile:build/top.mk:libraries/liblber/Makefile.in:build/lib.mk:build/lib-shared.mk	\
libraries/libldap/Makefile:build/top.mk:libraries/libldap/Makefile.in:build/lib.mk:build/lib-shared.mk	\
libraries/libldap_r/Makefile:build/top.mk:libraries/libldap_r/Makefile.in:build/lib.mk:build/lib-shared.mk	\
libraries/liblunicode/Makefile:build/top.mk:libraries/liblunicode/Makefile.in:build/lib.mk:build/lib-static.mk	\
libraries/liblutil/Makefile:build/top.mk:libraries/liblutil/Makefile.in:build/lib.mk:build/lib-static.mk	\
libraries/librewrite/Makefile:build/top.mk:libraries/librewrite/Makefile.in:build/lib.mk:build/lib-static.mk \
servers/Makefile:build/top.mk:servers/Makefile.in:build/dir.mk \
servers/slapd/Makefile:build/top.mk:servers/slapd/Makefile.in:build/srv.mk \
servers/slapd/back-bdb/Makefile:build/top.mk:servers/slapd/back-bdb/Makefile.in:build/mod.mk \
servers/slapd/back-dnssrv/Makefile:build/top.mk:servers/slapd/back-dnssrv/Makefile.in:build/mod.mk \
servers/slapd/back-hdb/Makefile:build/top.mk:servers/slapd/back-hdb/Makefile.in:build/mod.mk \
servers/slapd/back-ldap/Makefile:build/top.mk:servers/slapd/back-ldap/Makefile.in:build/mod.mk \
servers/slapd/back-ldbm/Makefile:build/top.mk:servers/slapd/back-ldbm/Makefile.in:build/mod.mk \
servers/slapd/back-meta/Makefile:build/top.mk:servers/slapd/back-meta/Makefile.in:build/mod.mk \
servers/slapd/back-monitor/Makefile:build/top.mk:servers/slapd/back-monitor/Makefile.in:build/mod.mk \
servers/slapd/back-null/Makefile:build/top.mk:servers/slapd/back-null/Makefile.in:build/mod.mk \
servers/slapd/back-passwd/Makefile:build/top.mk:servers/slapd/back-passwd/Makefile.in:build/mod.mk \
servers/slapd/back-perl/Makefile:build/top.mk:servers/slapd/back-perl/Makefile.in:build/mod.mk \
servers/slapd/back-shell/Makefile:build/top.mk:servers/slapd/back-shell/Makefile.in:build/mod.mk \
servers/slapd/back-sql/Makefile:build/top.mk:servers/slapd/back-sql/Makefile.in:build/mod.mk \
servers/slapd/shell-backends/Makefile:build/top.mk:servers/slapd/shell-backends/Makefile.in:build/srv.mk \
servers/slapd/slapi/Makefile:build/top.mk:servers/slapd/slapi/Makefile.in:build/lib.mk:build/lib-shared.mk  \
servers/slapd/overlays/Makefile:build/top.mk:servers/slapd/overlays/Makefile.in:build/lib.mk:build/lib-shared.mk  \
servers/slapd/tools/Makefile:build/top.mk:servers/slapd/tools/Makefile.in \
servers/slurpd/Makefile:build/top.mk:servers/slurpd/Makefile.in:build/srv.mk \
tests/Makefile:build/top.mk:tests/Makefile.in:build/dir.mk \
tests/run \
tests/progs/Makefile:build/top.mk:tests/progs/Makefile.in:build/rules.mk \
,[
chmod +x tests/run
date > stamp-h
echo Please run \"make depend\" to build dependencies
])