Skip to content
Snippets Groups Projects
configure.in 41.4 KiB
Newer Older
dnl
dnl Copyright 1998,1999 The OpenLDAP Foundation.  All Rights Reserved.
dnl 
dnl Redistribution and use in source and binary forms are permitted only
dnl as authorized by the OpenLDAP Public License.  A copy of this
dnl license is available at http://www.OpenLDAP.org/license.html or
dnl in file LICENSE in the top-level directory of the distribution.
dnl Configure.in for OpenLDAP
AC_INIT(include/ldap.h)dnl
AC_CONFIG_AUX_DIR(build)dnl
AM_INIT_AUTOMAKE(OpenLDAP,[2.0-devel], [no ac_define])dnl

dnl Do not use AutoConf 2.12; it produces a configuration script
dnl that causes an "internal 2K buffer" error on HPUX when run
dnl with /bin/sh.  Autoconf 2.10 seems to be okay.
AC_PREREQ(2.13)dnl Required Autoconf version
AC_CONFIG_HEADER(include/portable.h include/ldap_features.h)dnl
dnl
dnl Start Args
AC_MSG_CHECKING(configure arguments)
AC_PREFIX_DEFAULT(/usr/local)

Kurt Zeilenga's avatar
Kurt Zeilenga committed
ldap_subdir="openldap"

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

AC_SUBST(ldap_subdir)dnl

OL_ARG_ENABLE(debug,[  --enable-debug 	enable debugging], yes)dnl
dnl OL_ARG_ENABLE(syslog,[  --enable-syslog	enable syslog support], auto)dnl
Kurt Zeilenga's avatar
Kurt Zeilenga committed
OL_ARG_ENABLE(proctitle,[  --enable-proctitle	enable proctitle support], yes)dnl
OL_ARG_ENABLE(cache,[  --enable-cache	enable caching], yes)dnl
OL_ARG_ENABLE(dns,[  --enable-dns		enable V2 DNS  extension], no)dnl
OL_ARG_ENABLE(referrals,[  --enable-referrals	enable V2 Referrals extension], yes)dnl
OL_ARG_ENABLE(cldap,[  --enable-cldap	enable connectionless ldap], no)dnl
OL_ARG_ENABLE(x_compile,[  --enable-x-compile	enable cross compiling],
	no, [yes no])dnl
dnl General "with" options
OL_ARG_ENABLE(dmalloc,[  --enable-dmalloc	enable debug malloc support], no)dnl

OL_ARG_WITH(kerberos,[  --with-kerberos	use Kerberos],
	auto, [auto k5 k4 afs yes no])
OL_ARG_WITH(threads,[  --with-threads	use threads],
	auto, [auto posix mach lwp yes no manual] )
OL_ARG_WITH(yielding_select,[  --with-yielding-select	with implicitly yielding select],
	auto, [auto yes no manual] )

dnl Server options

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

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

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

OL_ARG_ENABLE(passwd,[    --enable-passwd	enable passwd backend], no)dnl
OL_ARG_ENABLE(perl,[    --enable-perl	enable perl backend], no)dnl
OL_ARG_ENABLE(shell,[    --enable-shell	enable shell backend], no)dnl

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

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

dnl General "enable" options
if test $ol_enable_dns = yes ; then
	if test $ol_enable_referrals = no ; then
		AC_MSG_ERROR([DNS requires --enable-referrals])
	fi
	if test $ol_enable_referrals = auto ; then
		AC_MSG_WARN([DNS requires referrals, adding --enable-referrals])
		ol_enable_referrals=yes
if test $ol_enable_slapd = no ; then
	dnl SLAPD was specificallly disabled
	if test $ol_enable_bdb2 = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_bdb2 argument])
	fi
	if test $ol_enable_ldbm = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_ldbm argument])
	fi
	if test $ol_enable_passwd = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_passwd argument])
	if test $ol_enable_perl = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_perl argument])
	fi
	if test $ol_enable_shell = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_shell argument])
	if test $ol_enable_aclgroups = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_aclgroups argument])
	fi
	if test $ol_enable_wrappers = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_wrappers argument])
	fi
	if test $ol_enable_phonetic = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_phonetic argument])
	fi
	if test $ol_enable_rlookups = yes ; then
		AC_MSG_WARN([slapd disabled, ignoring --enable_rlookups argument])
	fi
	if test $ol_with_ldbm_api != auto ; then
		AC_MSG_WARN([slapd disabled, ignoring --with_ldbm_api argument])
	fi
	if test $ol_with_ldbm_type != auto ; then
		AC_MSG_WARN([slapd disabled, ignoring --with_ldbm_type argument])
	fi
	if test $ol_enable_slurpd = yes ; then
		AC_MSG_ERROR([slurpd requires slapd])
	fi

	# force settings to no
	ol_enable_ldbm=no
	ol_enable_passwd=no
	ol_enable_perl=no
	ol_enable_shell=no
	ol_enable_aclgroups=no
	ol_enable_wrappers=no
	ol_enable_phonetic=no
	ol_enable_rlookups=no
	ol_with_ldbm_api=no
	ol_with_ldbm_type=no
	ol_enable_slurpd=no

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

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

	if test $ol_with_ldbm_type != auto ; then
		AC_MSG_WARN([LDBM disabled, ignoring --with_ldbm_type argument])
	if test $ol_enable_ldbm = yes ; then
		AC_MSG_ERROR([BDB2 requires --enable-ldbm])
	fi

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

	ol_with_ldbm_api=no
	ol_with_ldbm_type=no

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

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

	ol_with_ldbm_api=db2

else
	dnl SLAPD with LDBM

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

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

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

AC_MSG_RESULT(done)

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

LDAPD_LIBS=
SLAPD_LIBS=
SLURPD_LIBS=

BUILD_LDAPD=no
BUILD_SLAPD=no
BUILD_SLURPD=no

BUILD_LDBM=no
BUILD_PASSWD=no
BUILD_SHELL=no
Kurt Zeilenga's avatar
Kurt Zeilenga committed
BUILD_THREAD=no
SLAPD_PERL_LDFLAGS=
SLAPD_PERL_CPPFLAGS=

KRB_LIBS=
TERMCAP_LIBS=

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

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

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

	if test "no$PERLBIN" = "no" ; then
		ol_enable_perl=no
	fi

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


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

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

elif test $cross_compiling = yes -a $ol_enable_x_compile = no; then
	AC_MSG_WARN([programs compiled here do not run here...])
	AC_MSG_ERROR([  if cross compiling,  add --enable-x-compile.])
dnl Checks for UNIX Variants
AC_AIX
AC_ISC_POSIX
AC_MINIX

dnl Checks for system services
AC_CYGWIN
AC_MINGW32
AC_EXEEXT
AC_OBJEXT

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

dnl AM_C_PROTOTYPES

dnl Checks for libraries

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

AC_CHECK_FUNC(socket, [have_socket=yes], [	
dnl
dnl hopefully we won't include too many libraries
dnl
	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 Check for resolver routines
AC_CHECK_FUNCS(res_search)
if test $ac_cv_func_res_search = "no" ; then 
	AC_CHECK_LIB(bind, res_search)
	if test "$ac_cv_lib_bind_res_search" = "yes" ; then
		AC_DEFINE(HAVE_RES_SEARCH,1)
	else
		AC_CHECK_LIB(resolv, res_search)
		if test "$ac_cv_lib_resolv_res_search" = "yes" ; then
dnl HP-UX requires -lV3
AC_CHECK_LIB(V3, sigset)

# ISODE tests
ol_link_isode=no
Kurt Zeilenga's avatar
Kurt Zeilenga committed
if test $ol_enable_ldapd != no ; then
	dnl look for ISODE libraries
	AC_CHECK_LIB(xtpp, main, [
		ol_link_isode=yes
		AC_DEFINE(HAVE_XTPP,1)
		LDAPD_LIBS="$LDAPD_LIBS -lxtpp -lxtdsap -lxtisode -losi"
		],:,[-lxtdsap -lxtisode -losi])
Kurt Zeilenga's avatar
Kurt Zeilenga committed
	AC_CHECK_LIB(dsap, main, [
		ol_link_isode=yes
Kurt Zeilenga's avatar
Kurt Zeilenga committed
		AC_DEFINE(HAVE_DSAP,1)
		LDAPD_LIBS="$LDAPD_LIBS -ldsap"
		],:,[-lisode])
Kurt Zeilenga's avatar
Kurt Zeilenga committed
	AC_CHECK_LIB(isode, main, [
		ol_link_isode=yes
Kurt Zeilenga's avatar
Kurt Zeilenga committed
		AC_DEFINE(HAVE_ISODE,1)
		LDAPD_LIBS="$LDAPD_LIBS -lisode"
		],:)
fi

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

	AC_PATH_PROG(PEPSY, pepsy)
fi
Kurt Zeilenga's avatar
Kurt Zeilenga committed
dnl
dnl check for kerberos
dnl
ol_link_kerberos=no

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

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

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

			AC_DEFINE(HAVE_KERBEROS)
			KRB_LIBS="-lkrb4 -lkrb5 -ldes425"
		fi
	fi
fi
if test $ol_with_kerberos = auto -o $ol_with_kerberos = k4 ; then
	AC_CHECK_HEADERS(krb.h des.h)

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

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

			AC_DEFINE(HAVE_KERBEROS)
			KRB_LIBS="-lkrb -ldes"
		fi
	fi
fi

Kurt Zeilenga's avatar
Kurt Zeilenga committed
dnl	if test $ol_link_kerberos = yes ; then
dnl		save_LIBS=$LIBS
dnl		LIBS="$KRB_LIBS $LIBS"
dnl		AC_CHECK_FUNCS(des_string_to_key)
dnl		LIBS=$save_LIBS
dnl fi
ol_link_threads=no
Kurt Zeilenga's avatar
Kurt Zeilenga committed
if test $ol_with_threads = auto -o $ol_with_threads = yes \
	-o $ol_with_threads = posix ; then

	AC_CHECK_HEADERS(pthread.h sched.h)

	if test $ac_cv_header_pthread_h = yes ; then
		OL_POSIX_THREAD_VERSION

		if test $ol_cv_pthread_version = final ; then
			AC_DEFINE(HAVE_PTHREADS_FINAL)
		elif test $ol_cv_pthread_version = draft4 ; then
			AC_DEFINE(HAVE_PTHREADS_D4)
		else
			AC_MSG_ERROR([unknown pthread version])
		fi

		# consider threads found
		ol_with_threads=found

		OL_LINUX_THREADS

		if test $ol_cv_linux_threads = yes ; then
			AC_DEFINE(HAVE_LINUX_THREADS,1)
		fi

		dnl Now the hard part, how to link?
		dnl
		dnl currently supported checks:
		dnl
		dnl 0)	pthread_create() in $LIBS
		dnl
		dnl Check special pthread (final) flags
		dnl 1)	pthread_create() with -kthread (FreeBSD)
		dnl 2)	pthread_create() with -pthread (FreeBSD)
		dnl 3)	pthread_create() with -pthreads (OSF/1)
		dnl 4)	pthread_create() with -thread (?)
		dnl
		dnl Check pthread (final) libraries
		dnl 5)	pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1)
		dnl 6)	pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1)
		dnl 7)	pthread_mutex_trylock() in -lpthread -lexc (OSF/1)
		dnl 8)	pthread_create() in -lpthread (many)
		dnl 9)	pthread_create() in -lc_r (FreeBSD)
		dnl 10)	pthread_create() in -lpthreads (many)
		dnl 11)	pthread_join() -Wl,-woff,85 -lpthreads (IRIX)
		dnl 12)	pthread_create() in HP-UX -lpthread (HP-UX 11)
		dnl
		dnl Check pthread (draft4) flags (to be depreciated)
		dnl 13)	pthread_create() with -threads (OSF/1)
		dnl
		dnl Check pthread (final) libraries (to be depreciated)
		dnl 14)	pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1)
		dnl 14)	pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1)
		dnl 14)	pthread_mutex_trylock() in -lpthreads -lexc (OSF/1)
		AC_CHECK_FUNC(pthread_create,[ol_link_threads=yes])

		if test $ol_link_threads = no ; then
			dnl try -kthread
			AC_CACHE_CHECK([for pthread_create with -kthread],
				[ol_cv_kthread_flag], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="-kthread $LIBS"
				AC_TRY_LINK([char pthread();],[
					pthread_create();
					], ol_cv_kthread_flag=yes, ol_cv_kthread_flag=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_kthread_flag = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -kthread"
				ol_link_threads=posix
			fi
		fi

		if test $ol_link_threads = no ; then
			dnl try -pthread
			AC_CACHE_CHECK([for pthread_create with -pthread],
				[ol_cv_pthread_flag], [
				save_LIBS="$LIBS"
				LIBS="-pthread $LIBS"
				AC_TRY_LINK([char pthread();],[
					pthread_create();
					], ol_cv_pthread_flag=yes, ol_cv_pthread_flag=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_pthread_flag = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -pthread"
				ol_link_threads=posix
			fi
		fi

Kurt Zeilenga's avatar
Kurt Zeilenga committed
		if test $ol_link_threads = no ; then
			dnl try -pthreads
			AC_CACHE_CHECK([for pthread_create with -pthreads],
				[ol_cv_pthreads_flag], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="-pthreads $LIBS"
				AC_TRY_LINK([char pthread();],[
					pthread_create();
					], ol_cv_pthreads_flag=yes, ol_cv_pthreads_flag=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_pthreads_flag = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -pthreads"
				ol_link_threads=posix
			fi
		fi

		if test $ol_link_threads = no ; then
			dnl try -thread
			AC_CACHE_CHECK([for pthread_create with -thread],
				[ol_cv_thread_flag], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="-thread $LIBS"
				AC_TRY_LINK([char pthread();],[
					pthread_create();
					], ol_cv_thread_flag=yes, ol_cv_thread_flag=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_thread_flag = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -thread"
				ol_link_threads=posix
			fi
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthread -lmach -lexc -lc_r
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthread, pthread_mutex_unlock, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc -lc_r"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
				fi
				],:,[-lmach -lexc -lc_r])
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthread -lmach -lexc
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthread, pthread_mutex_lock, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lmach -lexc"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
				],:,[-lmach -lexc])
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthread -lexc
			AC_CHECK_LIB(pthread, pthread_mutex_trylock, [
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthread -lexc"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthread, pthread_create, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"],:)
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			save_LIBS="$LIBS"
			AC_CHECK_LIB(c_r, pthread_create, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lc_r"],:)
			LIBS="$save_LIBS"
		fi

Kurt Zeilenga's avatar
Kurt Zeilenga committed
		if test $ol_link_threads = no ; then
			dnl try -lpthreads
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthreads, pthread_create, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"],:)
Kurt Zeilenga's avatar
Kurt Zeilenga committed
			LIBS="$save_LIBS"
		fi

		dnl IRIX Pthread check
		if test $ol_link_threads = no ; then
			dnl try IRIX Pthreads -Wl,-woff,85 -lpthreads
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthreads, pthread_join, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads"
				],:,[-Wl,-woff,85])
			LIBS="$save_LIBS"
		fi

		dnl HP-UX 11 Pthread check
		if test $ol_link_threads = no; then
			save_LIBS="$LIBS"
			LIBS="$LIBS -lpthread"
			AC_MSG_CHECKING([for pthread_create() in HP-UX -lpthread])
			ol_try_pthread_hpux_11=no
			AC_CACHE_VAL(ol_cv_pthread_hpux_11,[
				AC_TRY_LINK([
#include <pthread.h>
#include <elf.h>
#ifndef ELFABI_HPUX_REL11
	die horribly
#endif
				], [pthread_create(NULL, NULL, NULL, NULL);],
					ol_try_pthread_hpux_11=yes
					ol_cv_pthread_hpux_11=yes,
					ol_cv_pthread_hpux_11=no)])
			AC_MSG_RESULT(yes)
			LIBS="$save_LIBS"

			if test $ol_cv_pthread_hpux_11=yes ; then
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthread"
				if test $ol_try_pthread_hpux_11=yes ; then
					dnl Some tests below may fail, cause we aint including
					dnl pthread.h. Force appropriate ones to yes
					ac_cv_func_pthread_attr_init=yes
				fi
			fi
		fi

		if test $ol_link_threads = no ; then
			dnl try -threads
			AC_CACHE_CHECK([for pthread_create with -threads],
				[ol_cv_thread_flag], [
				dnl save the flags
				save_LIBS="$LIBS"
				LIBS="-threads $LIBS"
				AC_TRY_LINK([char pthread();],[
					pthread_create();
					], ol_cv_thread_flag=yes, ol_cv_thread_flag=no)
				dnl restore the LIBS
				LIBS="$save_LIBS"
			])

			if test $ol_cv_thread_flag = yes ; then
				LTHREAD_LIBS="$LTHREAD_LIBS -threads"
				ol_link_threads=posix
			fi
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthreads -lmach -lexc -lc_r
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthreads, pthread_mutex_unlock, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc -lc_r"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
				fi
				],:,[-lmach -lexc -lc_r])
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthreads -lmach -lexc
			save_LIBS="$LIBS"
			AC_CHECK_LIB(pthreads, pthread_mutex_lock, [
				ol_link_threads=posix
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lmach -lexc"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
				fi
				],:,[-lmach -lexc])
			LIBS="$save_LIBS"
		fi

		if test $ol_link_threads = no ; then
			dnl try DEC Threads -lpthreads -lexc
			AC_CHECK_LIB(pthreads, pthread_mutex_trylock, [
				LTHREAD_LIBS="$LTHREAD_LIBS -lpthreads -lexc"
				if test $ol_with_yielding_select = auto ; then
					ol_with_yielding_select=yes
				fi
		if test $ol_link_threads != no ; then
			AC_DEFINE(HAVE_PTHREADS)

			save_CPPFLAGS="$CPPFLAGS"
			save_LIBS="$LIBS"
			LIBS="$LTHREAD_LIBS $LIBS"

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

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

			dnl Check functions for compatibility
			AC_CHECK_FUNCS(pthread_kill pthread_detach)

			if test $ac_cv_func_pthread_detach = no ; then
				AC_MSG_ERROR([could not locate pthread_detach()])
			fi
			dnl Check for setconcurreny functions
			AC_CHECK_FUNCS(	\
				pthread_setconcurrency \
				pthread_getconcurrency \
				thr_setconcurrency \
				thr_getconcurrency \
			AC_MSG_CHECKING([if pthread_create() works])
			AC_CACHE_VAL(ol_cv_pthread_create_works,[
			AC_TRY_RUN([
#include <pthread.h>
#ifndef NULL
#define NULL (void*)0
#endif
static void *task(p)
	void *p;
{
	return (void *) (p == NULL);
}

int main(argc, argv)
	int argc;
	char **argv;
{
	pthread_t t;
	exit(pthread_create(&t, NULL, task, NULL));
}
],
				[ol_cv_pthread_create_works=yes],
				[ol_cv_pthread_create_works=no],
				[dnl assume yes
				ol_cv_pthread_create_works=yes])])
			AC_MSG_RESULT($ol_cv_pthread_create_works)

			if test $ol_cv_pthread_create_works = no ; then
				AC_MSG_ERROR([pthread.h and pthread_create are not compatible])
			fi

			dnl Check if select causes an yield
			if test $ol_with_yielding_select = auto ; then
				AC_MSG_CHECKING([if select yields when using pthreads])
				AC_CACHE_VAL(ol_cv_pthread_select_yields,[
				AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <pthread.h>
#ifndef NULL
#define NULL (void*) 0
static int fildes[2];
static void *task(p)
	void *p;
	struct timeval tv;

	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");
Kurt Zeilenga's avatar
Kurt Zeilenga committed
		exit(10);
Kurt Zeilenga's avatar
Kurt Zeilenga committed
	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");
Kurt Zeilenga's avatar
Kurt Zeilenga committed
		exit(1);
#ifdef HAVE_PTHREAD_SETCONCURRENCY
	(void) pthread_setconcurrency(2);
#else
#ifdef HAVE_THR_SETCONCURRENCY
	/* Set Solaris LWP concurrency to 2 */
	thr_setconcurrency(2);
	pthread_create(&t, NULL, task, NULL);

#if HAVE_SCHED_YIELD
	sched_yield();	/* make sure task runs first */
#else
#ifdef HAVE_PTHREAD_YIELD
	pthread_yield();	/* make sure task runs first */
#endif
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed

	exit(2);
Kurt Zeilenga's avatar
Kurt Zeilenga committed
				[ol_cv_pthread_select_yields=no],
				[ol_cv_pthread_select_yields=yes], [
				AC_MSG_ERROR([crossing compiling: use --with-yielding_select=yes|no|manual])])])
				AC_MSG_RESULT($ol_cv_pthread_select_yields)
				if test $ol_cv_pthread_select_yields = yes ; then
			CPPFLAGS="$save_CPPFLAGS"
			LIBS="$save_LIBS"
		else
			AC_MSG_ERROR([could not link with POSIX Threads])
		fi
	fi

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

Kurt Zeilenga's avatar
Kurt Zeilenga committed
if test $ol_with_threads = auto -o $ol_with_threads = yes \
	-o $ol_with_threads = mach ; then

	dnl check for Mach CThreads
	AC_CHECK_HEADERS(mach/cthreads.h)
	if test $ac_cv_header_mach_cthreads_h = yes ; then
		ol_with_threads=found
		dnl check for cthread 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], [
				save_LIBS="$LIBS"
				LIBS="-all_load $LIBS"
				AC_TRY_LINK([#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
			fi

		if test $ol_link_threads != no ; then
			: check for cthread specific functionality here
			AC_DEFINE(HAVE_MACH_CTHREADS,1)
		else
			AC_MSG_ERROR([could not link with Mach CThreads])
		fi
	fi

	if test $ol_with_threads = mach ; then
		AC_MSG_ERROR([could not locate Mach CThreads])
Kurt Zeilenga's avatar
Kurt Zeilenga committed
if test $ol_with_threads = auto -o $ol_with_threads = yes \
	-o $ol_with_threads = lwp ; then

	dnl check for SunOS5 LWP
	AC_CHECK_HEADERS(thread.h synch.h)
	if test $ac_cv_header_thread_h = yes -a $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)
			LTHREAD_LIBS="$LTHREAD_LIBS -lthread"
			ol_link_threads=thr
			if test $ol_with_yielding_select = auto ; then
				ol_with_yielding_select=yes
			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)
			LTHREAD_LIBS="$LTHREAD_LIBS -llwp"
			ol_link_threads=lwp
			if test $ol_with_yielding_select = auto ; then
				ol_with_yielding_select=no
if test $ol_with_yielding_select = yes ; then