openldap-thread-check.m4 revision 290001 
1dnl OpenLDAP Autoconf thread check
2dnl
3dnl This work is part of OpenLDAP Software <http://www.openldap.org/>.
4dnl
5dnl Copyright 1998-2010 The OpenLDAP Foundation.
6dnl All rights reserved.
7dnl
8dnl Redistribution and use in source and binary forms, with or without
9dnl modification, are permitted only as authorized by the OpenLDAP
10dnl Public License.
11dnl
12dnl A copy of this license is available in the file LICENSE-OPENLDAP in
13dnl this directory of the distribution or, alternatively, at
14dnl <http://www.OpenLDAP.org/license.html>.
15dnl
16dnl --------------------------------------------------------------------
17
18dnl This file is a fragment of OpenLDAP's build/openldap.m4 and some
19dnl fragments of OpenLDAP's configure.ac .
20
21#   OL_THREAD_CHECK([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
22
23AC_DEFUN([OL_THREAD_CHECK], [
24AC_REQUIRE([AC_CANONICAL_HOST])
25AC_LANG_SAVE
26AC_LANG([C])
27OL_ARG_WITH(threads,[  --with-threads	  with threads],
28	auto, [auto nt posix mach pth lwp yes no manual] )
29
30case "$ol_with_threads$host" in
31 auto*-*-solaris2.[[0-6]])
32    dnl signals sometimes delivered to wrong thread with Solaris 2.6
33    ol_with_threads=no
34    ;;
35esac
36
37dnl AIX Thread requires we use cc_r or xlc_r.
38dnl But only do this IF AIX and CC is not set
39dnl and threads are auto|yes|posix.
40dnl
41dnl If we find cc_r|xlc_r, force pthreads and assume
42dnl		pthread_create is in $LIBS (ie: don't bring in
43dnl		any additional thread libraries)
44dnl If we do not find cc_r|xlc_r, disable threads
45
46ol_aix_threads=no
47case "$host" in
48*-*-aix*) dnl all AIX is not a good idea.
49	if test -z "$CC" ; then
50		case "$ol_with_threads" in
51		auto | yes |  posix) ol_aix_threads=yes ;;
52		esac
53	fi
54;;
55esac
56
57if test $ol_aix_threads = yes ; then
58	if test -z "${CC}" ; then
59		AC_CHECK_PROGS(CC,cc_r xlc_r cc)
60
61		if test "$CC" = cc ; then
62			dnl no CC! don't allow --with-threads
63			if test $ol_with_threads != auto ; then
64				AC_MSG_ERROR([--with-threads requires cc_r (or other suitable compiler) on AIX])
65			else
66				AC_MSG_WARN([disabling threads, no cc_r on AIX])
67			fi
68			ol_with_threads=no
69  		fi
70	fi
71
72	case ${CC} in cc_r | xlc_r)
73		ol_with_threads=posix
74		ol_cv_pthread_create=yes
75		;;
76	esac
77fi
78
79dnl ----------------------------------------------------------------
80dnl Threads?
81ol_link_threads=no
82dnl ol_with_yielding_select=${ol_with_yielding_select:-auto}
83OL_ARG_WITH(yielding_select,[  --with-yielding-select  with yielding select],
84	auto, [auto yes no manual] )
85
86case $ol_with_threads in auto | yes | nt)
87
88	OL_NT_THREADS
89
90	if test "$ol_cv_nt_threads" = yes ; then
91		ol_link_threads=nt
92		ol_with_threads=found
93		ol_with_yielding_select=yes
94
95		AC_DEFINE([HAVE_NT_SERVICE_MANAGER], [1], [if you have NT Service Manager])
96		AC_DEFINE([HAVE_NT_EVENT_LOG], [1], [if you have NT Event Log])
97	fi
98
99	if test $ol_with_threads = nt ; then
100		AC_MSG_ERROR([could not locate NT Threads])
101	fi
102	;;
103esac
104
105case $ol_with_threads in auto | yes | posix)
106
107	AC_CHECK_HEADERS(pthread.h)
108
109	if test $ac_cv_header_pthread_h = yes ; then
110		OL_POSIX_THREAD_VERSION
111
112		if test $ol_cv_pthread_version != 0 ; then
113			AC_DEFINE_UNQUOTED([HAVE_PTHREADS], [$ol_cv_pthread_version],
114				[define to pthreads API spec revision])
115		else
116			AC_MSG_ERROR([unknown pthread version])
117		fi
118
119		# consider threads found
120		ol_with_threads=found
121
122		OL_HEADER_LINUX_THREADS
123		OL_HEADER_GNU_PTH_PTHREAD_H
124
125		if test $ol_cv_header_gnu_pth_pthread_h = no ; then
126			AC_CHECK_HEADERS(sched.h)
127		fi
128
129		dnl Now the hard part, how to link?
130		dnl
131		dnl currently supported checks:
132		dnl
133		dnl Check for no flags 
134		dnl 	pthread_create() in $LIBS
135		dnl
136		dnl Check special pthread (final) flags
137		dnl 	[skipped] pthread_create() with -mt (Solaris) [disabled]
138		dnl 	pthread_create() with -kthread (FreeBSD)
139		dnl 	pthread_create() with -pthread (FreeBSD/Digital Unix)
140		dnl 	pthread_create() with -pthreads (?)
141		dnl 	pthread_create() with -mthreads (AIX)
142		dnl 	pthread_create() with -thread (?)
143		dnl
144		dnl Check pthread (final) libraries
145		dnl 	pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1)
146		dnl 	pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1)
147		dnl 	[skipped] pthread_mutex_trylock() in -lpthread -lexc (OSF/1)
148		dnl 	pthread_join() -Wl,-woff,85 -lpthread (IRIX)
149		dnl 	pthread_create() in -lpthread (many)
150		dnl 	pthread_create() in -lc_r (FreeBSD)
151		dnl
152		dnl Check pthread (draft4) flags (depreciated)
153		dnl 	pthread_create() with -threads (OSF/1)
154		dnl
155		dnl Check pthread (draft4) libraries (depreciated)
156		dnl 	pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1)
157		dnl 	pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1)
158		dnl 	pthread_mutex_trylock() in -lpthreads -lexc (OSF/1)
159		dnl 	pthread_create() in -lpthreads (many)
160		dnl
161
162		dnl pthread_create in $LIBS
163		AC_CACHE_CHECK([for pthread_create in default libraries],
164			ol_cv_pthread_create,[
165			AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM],
166				[ol_cv_pthread_create=yes],
167				[ol_cv_pthread_create=no],
168				[AC_TRY_LINK(OL_PTHREAD_TEST_INCLUDES,OL_PTHREAD_TEST_FUNCTION,
169					[ol_cv_pthread_create=yes],
170					[ol_cv_pthread_create=no])])])
171
172		if test $ol_cv_pthread_create != no ; then
173			ol_link_threads=posix
174			ol_link_pthreads=""
175		fi
176		
177dnl		OL_PTHREAD_TRY([-mt],		[ol_cv_pthread_mt])
178		OL_PTHREAD_TRY([-kthread],	[ol_cv_pthread_kthread])
179		OL_PTHREAD_TRY([-pthread],	[ol_cv_pthread_pthread])
180		OL_PTHREAD_TRY([-pthreads],	[ol_cv_pthread_pthreads])
181		OL_PTHREAD_TRY([-mthreads],	[ol_cv_pthread_mthreads])
182		OL_PTHREAD_TRY([-thread],	[ol_cv_pthread_thread])
183
184		OL_PTHREAD_TRY([-lpthread -lmach -lexc -lc_r],
185			[ol_cv_pthread_lpthread_lmach_lexc_lc_r])
186		OL_PTHREAD_TRY([-lpthread -lmach -lexc],
187			[ol_cv_pthread_lpthread_lmach_lexc])
188dnl		OL_PTHREAD_TRY([-lpthread -lexc],
189dnl			[ol_cv_pthread_lpthread_lexc])
190
191		OL_PTHREAD_TRY([-lpthread -Wl,-woff,85],
192			[ol_cv_pthread_lib_lpthread_woff])
193
194		OL_PTHREAD_TRY([-lpthread],	[ol_cv_pthread_lpthread])
195		OL_PTHREAD_TRY([-lc_r],		[ol_cv_pthread_lc_r])
196
197		OL_PTHREAD_TRY([-threads],	[ol_cv_pthread_threads])
198
199		OL_PTHREAD_TRY([-lpthreads -lmach -lexc -lc_r],
200			[ol_cv_pthread_lpthreads_lmach_lexc_lc_r])
201		OL_PTHREAD_TRY([-lpthreads -lmach -lexc],
202			[ol_cv_pthread_lpthreads_lmach_lexc])
203		OL_PTHREAD_TRY([-lpthreads -lexc],
204			[ol_cv_pthread_lpthreads_lexc])
205
206		OL_PTHREAD_TRY([-lpthreads],[ol_cv_pthread_lib_lpthreads])
207
208AC_MSG_NOTICE([ol_link_threads: <$ol_link_threads> ol_link_pthreads <$ol_link_pthreads>])
209
210		if test $ol_link_threads != no ; then
211			LTHREAD_LIBS="$LTHREAD_LIBS $ol_link_pthreads"
212
213			dnl save flags
214			save_CPPFLAGS="$CPPFLAGS"
215			save_LIBS="$LIBS"
216			LIBS="$LTHREAD_LIBS $LIBS"
217
218			dnl All POSIX Thread (final) implementations should have
219			dnl sched_yield instead of pthread yield.
220			dnl check for both, and thr_yield for Solaris
221			AC_CHECK_FUNCS(sched_yield pthread_yield thr_yield)
222
223			if test $ac_cv_func_sched_yield = no &&
224			   test $ac_cv_func_pthread_yield = no &&
225			   test $ac_cv_func_thr_yield = no ; then
226				dnl Digital UNIX has sched_yield() in -lrt
227				AC_CHECK_LIB(rt, sched_yield,
228					[LTHREAD_LIBS="$LTHREAD_LIBS -lrt"
229					AC_DEFINE([HAVE_SCHED_YIELD], [1],
230						[Define if you have the sched_yield function.])
231					ac_cv_func_sched_yield=yes],
232					[ac_cv_func_sched_yield=no])
233			fi
234			if test $ac_cv_func_sched_yield = no &&
235			   test $ac_cv_func_pthread_yield = no &&
236			   test "$ac_cv_func_thr_yield" = no ; then
237				AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])
238			fi
239
240			dnl Check functions for compatibility
241			AC_CHECK_FUNCS(pthread_kill)
242
243			dnl Check for pthread_rwlock_destroy with <pthread.h>
244			dnl as pthread_rwlock_t may not be defined.
245			AC_CACHE_CHECK([for pthread_rwlock_destroy with <pthread.h>],
246				[ol_cv_func_pthread_rwlock_destroy], [
247				dnl save the flags
248				AC_LINK_IFELSE([AC_LANG_PROGRAM([[
249#include <pthread.h>
250pthread_rwlock_t rwlock;
251]], [[pthread_rwlock_destroy(&rwlock);]])],[ol_cv_func_pthread_rwlock_destroy=yes],[ol_cv_func_pthread_rwlock_destroy=no])
252			])
253			if test $ol_cv_func_pthread_rwlock_destroy = yes ; then
254				AC_DEFINE([HAVE_PTHREAD_RWLOCK_DESTROY], [1],
255					[define if you have pthread_rwlock_destroy function])
256			fi
257
258			dnl Check for pthread_detach with <pthread.h> inclusion
259			dnl as it's symbol may have been mangled.
260			AC_CACHE_CHECK([for pthread_detach with <pthread.h>],
261				[ol_cv_func_pthread_detach], [
262				dnl save the flags
263				AC_LINK_IFELSE([AC_LANG_PROGRAM([[
264#include <pthread.h>
265#ifndef NULL
266#define NULL (void*)0
267#endif
268]], [[pthread_detach(NULL);]])],[ol_cv_func_pthread_detach=yes],[ol_cv_func_pthread_detach=no])
269			])
270
271			if test $ol_cv_func_pthread_detach = no ; then
272				AC_MSG_ERROR([could not locate pthread_detach()])
273			fi
274
275			AC_DEFINE([HAVE_PTHREAD_DETACH], [1],
276				[define if you have pthread_detach function])
277
278			dnl Check for setconcurreny functions
279			AC_CHECK_FUNCS(	\
280				pthread_setconcurrency \
281				pthread_getconcurrency \
282				thr_setconcurrency \
283				thr_getconcurrency \
284			)
285
286			OL_SYS_LINUX_THREADS
287			OL_LINUX_THREADS
288
289			if test $ol_cv_linux_threads = error; then
290				AC_MSG_ERROR([LinuxThreads header/library mismatch]);
291			fi
292
293			AC_CACHE_CHECK([if pthread_create() works],
294				ol_cv_pthread_create_works,[
295			AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM],
296				[ol_cv_pthread_create_works=yes],
297				[ol_cv_pthread_create_works=no],
298				[dnl assume yes
299				ol_cv_pthread_create_works=yes])])
300
301			if test $ol_cv_pthread_create_works = no ; then
302				AC_MSG_ERROR([pthread_create is not usable, check environment settings])
303			fi
304
305			ol_replace_broken_yield=no
306dnl			case "$host" in
307dnl			*-*-linux*) 
308dnl				AC_CHECK_FUNCS(nanosleep)
309dnl				ol_replace_broken_yield=yes
310dnl			;;
311dnl			esac
312
313			if test $ol_replace_broken_yield = yes ; then
314				AC_DEFINE([REPLACE_BROKEN_YIELD], [1],
315					[define if sched_yield yields the entire process])
316			fi
317
318			dnl Check if select causes an yield
319			if test x$ol_with_yielding_select = xauto ; then
320				AC_CACHE_CHECK([if select yields when using pthreads],
321					ol_cv_pthread_select_yields,[
322				AC_RUN_IFELSE([AC_LANG_SOURCE([[
323#include <sys/types.h>
324#include <sys/time.h>
325#include <unistd.h>
326#include <pthread.h>
327#ifndef NULL
328#define NULL (void*) 0
329#endif
330
331static int fildes[2];
332
333static void *task(p)
334	void *p;
335{
336	int i;
337	struct timeval tv;
338
339	fd_set rfds;
340
341	tv.tv_sec=10;
342	tv.tv_usec=0;
343
344	FD_ZERO(&rfds);
345	FD_SET(fildes[0], &rfds);
346
347	/* we're not interested in any fds */
348	i = select(FD_SETSIZE, &rfds, NULL, NULL, &tv);
349
350	if(i < 0) {
351		perror("select");
352		exit(10);
353	}
354
355	exit(0); /* if we exit here, the select blocked the whole process */
356}
357
358int main(argc, argv)
359	int argc;
360	char **argv;
361{
362	pthread_t t;
363
364	/* create a pipe to select */
365	if(pipe(&fildes[0])) {
366		perror("select");
367		exit(1);
368	}
369
370#ifdef HAVE_PTHREAD_SETCONCURRENCY
371	(void) pthread_setconcurrency(2);
372#else
373#ifdef HAVE_THR_SETCONCURRENCY
374	/* Set Solaris LWP concurrency to 2 */
375	thr_setconcurrency(2);
376#endif
377#endif
378
379#if HAVE_PTHREADS < 6
380	pthread_create(&t, pthread_attr_default, task, NULL);
381#else
382	pthread_create(&t, NULL, task, NULL);
383#endif
384
385	/* make sure task runs first */
386#ifdef HAVE_THR_YIELD
387	thr_yield();
388#elif defined( HAVE_SCHED_YIELD )
389	sched_yield();
390#elif defined( HAVE_PTHREAD_YIELD )
391	pthread_yield();
392#endif
393
394	exit(2);
395}]])],[ol_cv_pthread_select_yields=no],[ol_cv_pthread_select_yields=yes],[ol_cv_pthread_select_yields=cross])])
396
397				if test $ol_cv_pthread_select_yields = cross ; then
398					AC_MSG_ERROR([crossing compiling: use --with-yielding-select=yes|no|manual])
399				fi
400
401				if test $ol_cv_pthread_select_yields = yes ; then
402					ol_with_yielding_select=yes
403				fi
404			fi
405
406			dnl restore flags
407			CPPFLAGS="$save_CPPFLAGS"
408			LIBS="$save_LIBS"
409		else
410			AC_MSG_ERROR([could not locate usable POSIX Threads])
411		fi
412	fi
413
414	if test $ol_with_threads = posix ; then
415		AC_MSG_ERROR([could not locate POSIX Threads])
416	fi
417	;;
418esac
419
420case $ol_with_threads in auto | yes | mach)
421
422	dnl check for Mach CThreads
423	AC_CHECK_HEADERS(mach/cthreads.h cthreads.h)
424	if test $ac_cv_header_mach_cthreads_h = yes ; then
425		ol_with_threads=found
426
427		dnl check for cthreads support in current $LIBS
428		AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes])
429
430		if test $ol_link_threads = no ; then
431			dnl try -all_load
432			dnl this test needs work
433			AC_CACHE_CHECK([for cthread_fork with -all_load],
434				[ol_cv_cthread_all_load], [
435				dnl save the flags
436				save_LIBS="$LIBS"
437				LIBS="-all_load $LIBS"
438				AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <mach/cthreads.h>]], [[
439					cthread_fork((void *)0, (void *)0);
440					]])],[ol_cv_cthread_all_load=yes],[ol_cv_cthread_all_load=no])
441				dnl restore the LIBS
442				LIBS="$save_LIBS"
443			])
444
445			if test $ol_cv_cthread_all_load = yes ; then
446				LTHREAD_LIBS="$LTHREAD_LIBS -all_load"
447				ol_link_threads=mach
448				ol_with_threads=found
449			fi
450		fi
451
452	elif test $ac_cv_header_cthreads_h = yes ; then
453		dnl Hurd variant of Mach Cthreads
454		dnl uses <cthreads.h> and -lthreads
455
456		ol_with_threads=found
457 
458		dnl save the flags
459		save_LIBS="$LIBS"
460		LIBS="$LIBS -lthreads"
461		AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes])
462		LIBS="$save_LIBS"
463
464		if test $ol_link_threads = yes ; then
465			LTHREAD_LIBS="-lthreads"
466			ol_link_threads=mach
467			ol_with_threads=found
468		else
469			AC_MSG_ERROR([could not link with Mach CThreads])
470		fi
471
472	elif test $ol_with_threads = mach ; then
473		AC_MSG_ERROR([could not locate Mach CThreads])
474	fi
475
476	if test $ol_link_threads = mach ; then
477		AC_DEFINE([HAVE_MACH_CTHREADS], [1],
478			[define if you have Mach Cthreads])
479	elif test $ol_with_threads = found ; then
480		AC_MSG_ERROR([could not link with Mach CThreads])
481	fi
482	;;
483esac
484
485case $ol_with_threads in auto | yes | pth)
486
487	AC_CHECK_HEADERS(pth.h)
488
489	if test $ac_cv_header_pth_h = yes ; then
490		AC_CHECK_LIB(pth, pth_version, [have_pth=yes], [have_pth=no])
491
492		if test $have_pth = yes ; then
493			AC_DEFINE([HAVE_GNU_PTH], [1], [if you have GNU Pth])
494			LTHREAD_LIBS="$LTHREAD_LIBS -lpth"
495			ol_link_threads=pth
496			ol_with_threads=found
497
498			if test x$ol_with_yielding_select = xauto ; then
499				ol_with_yielding_select=yes
500			fi
501		fi
502	fi
503	;;
504esac
505
506case $ol_with_threads in auto | yes | lwp)
507
508	dnl check for SunOS5 LWP
509	AC_CHECK_HEADERS(thread.h synch.h)
510	if test $ac_cv_header_thread_h = yes &&
511	   test $ac_cv_header_synch_h = yes ; then
512		AC_CHECK_LIB(thread, thr_create, [have_thr=yes], [have_thr=no])
513
514		if test $have_thr = yes ; then
515			AC_DEFINE([HAVE_THR], [1],
516				[if you have Solaris LWP (thr) package])
517			LTHREAD_LIBS="$LTHREAD_LIBS -lthread"
518			ol_link_threads=thr
519
520			if test x$ol_with_yielding_select = xauto ; then
521				ol_with_yielding_select=yes
522			fi
523
524			dnl Check for setconcurrency functions
525			AC_CHECK_FUNCS(	\
526				thr_setconcurrency \
527				thr_getconcurrency \
528			)
529		fi
530	fi
531
532	dnl check for SunOS4 LWP
533	AC_CHECK_HEADERS(lwp/lwp.h)
534	if test $ac_cv_header_lwp_lwp_h = yes ; then
535		AC_CHECK_LIB(lwp, lwp_create, [have_lwp=yes], [have_lwp=no])
536
537		if test $have_lwp = yes ; then
538			AC_DEFINE([HAVE_LWP], [1],
539				[if you have SunOS LWP package])
540			LTHREAD_LIBS="$LTHREAD_LIBS -llwp"
541			ol_link_threads=lwp
542
543			if test x$ol_with_yielding_select = xauto ; then
544				ol_with_yielding_select=no
545			fi
546		fi
547	fi
548	;;
549esac
550
551if test $ol_with_yielding_select = yes ; then
552	AC_DEFINE([HAVE_YIELDING_SELECT], [1],
553		[define if select implicitly yields])
554fi
555
556if test $ol_with_threads = manual ; then
557	dnl User thinks he can manually configure threads.
558	ol_link_threads=yes
559
560	AC_MSG_WARN([thread defines and link options must be set manually])
561
562	AC_CHECK_HEADERS(pthread.h sched.h)
563	AC_CHECK_FUNCS(sched_yield pthread_yield)
564	OL_HEADER_LINUX_THREADS
565
566	AC_CHECK_HEADERS(mach/cthreads.h)
567	AC_CHECK_HEADERS(lwp/lwp.h)
568	AC_CHECK_HEADERS(thread.h synch.h)
569fi
570
571if test $ol_link_threads != no && test $ol_link_threads != nt ; then
572	dnl needed to get reentrant/threadsafe versions
573	dnl
574	AC_DEFINE([REENTRANT], [1], [enable thread safety])
575	AC_DEFINE([_REENTRANT], [1], [enable thread safety])
576	AC_DEFINE([THREAD_SAFE], [1], [enable thread safety])
577	AC_DEFINE([_THREAD_SAFE], [1], [enable thread safety])
578	AC_DEFINE([THREADSAFE], [1], [enable thread safety])
579	AC_DEFINE([_THREADSAFE], [1], [enable thread safety])
580	AC_DEFINE([_SGI_MP_SOURCE], [1], [enable thread safety])
581
582	dnl The errno declaration may dependent upon _REENTRANT.
583	dnl If it does, we must link with thread support.
584	AC_CACHE_CHECK([for thread specific errno],
585		[ol_cv_errno_thread_specific], [
586		AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], [[errno = 0;]])],[ol_cv_errno_thread_specific=yes],[ol_cv_errno_thread_specific=no])
587	])
588
589	dnl The h_errno declaration may dependent upon _REENTRANT.
590	dnl If it does, we must link with thread support.
591	AC_CACHE_CHECK([for thread specific h_errno],
592		[ol_cv_h_errno_thread_specific], [
593		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])
594	])
595
596	if test $ol_cv_errno_thread_specific != yes ||
597	   test $ol_cv_h_errno_thread_specific != yes ; then
598		LIBS="$LTHREAD_LIBS $LIBS"
599		LTHREAD_LIBS=""
600	fi
601
602dnl When in thread environment, use 
603dnl		#if defined( HAVE_REENTRANT_FUNCTIONS ) || defined( HAVE_FUNC_R )
604dnl			func_r(...);
605dnl		#else
606dnl		#	if defined( HAVE_THREADS ) 
607dnl				/* lock */
608dnl		#	endif
609dnl				func(...);
610dnl		#	if defined( HAVE_THREADS ) 
611dnl				/* unlock */
612dnl		#	endif
613dnl		#endif
614dnl
615dnl HAVE_REENTRANT_FUNCTIONS is derived from:
616dnl		_POSIX_REENTRANT_FUNCTIONS
617dnl		_POSIX_THREAD_SAFE_FUNCTIONS
618dnl		_POSIX_THREADSAFE_FUNCTIONS
619dnl
620dnl		and is currently defined in <ldap_pvt_thread.h>
621dnl
622dnl HAVE_THREADS is defined by <ldap_pvt_thread.h> iff -UNO_THREADS
623dnl 
624dnl libldap/*.c should only include <ldap_pvt_thread.h> iff
625dnl LDAP_R_COMPILE is defined.  ie:
626dnl		#ifdef LDAP_R_COMPILE
627dnl		#	include <ldap_pvt_thread.h>
628dnl		#endif
629dnl
630dnl LDAP_R_COMPILE is defined by libldap_r/Makefile.in
631dnl specifically for compiling the threadsafe version of
632dnl	the ldap library (-lldap_r).
633dnl		
634dnl	dnl check for reentrant/threadsafe functions
635dnl	dnl
636dnl	dnl note: these should only be used when linking
637dnl	dnl		with $LTHREAD_LIBS
638dnl	dnl
639dnl	save_CPPFLAGS="$CPPFLAGS"
640dnl	save_LIBS="$LIBS"
641dnl	LIBS="$LTHREAD_LIBS $LIBS"
642dnl	AC_CHECK_FUNCS(	\
643dnl		gmtime_r \
644dnl		gethostbyaddr_r gethostbyname_r \
645dnl		feof_unlocked unlocked_feof \
646dnl		putc_unlocked unlocked_putc \
647dnl		flockfile ftrylockfile \
648dnl	)
649dnl	CPPFLAGS="$save_CPPFLAGS"
650dnl	LIBS="$save_LIBS"
651fi  
652
653if test $ol_link_threads = no ; then
654	if test $ol_with_threads = yes ; then
655		AC_MSG_ERROR([no suitable thread support])
656	fi
657
658	if test $ol_with_threads = auto ; then
659		AC_MSG_WARN([no suitable thread support, disabling threads])
660		ol_with_threads=no
661	fi
662
663	AC_DEFINE([NO_THREADS], [1],
664		[define if you have (or want) no threads])
665	LTHREAD_LIBS=""
666	BUILD_THREAD=no
667else
668	BUILD_THREAD=yes
669fi
670
671if test $ol_link_threads != no ; then
672	AC_DEFINE([LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE], [1],
673		[define to 1 if library is thread safe])
674fi
675
676# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
677case "$ol_with_threads" in
678 no)
679    ol_pthread_ok=no
680    $2
681    ;;
682 *)
683    ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
684    ;;
685esac
686
687AC_LANG_RESTORE
688
689AC_SUBST(BUILD_THREAD)
690AC_SUBST(LTHREAD_LIBS)
691
692])
693