Context Navigation

configure.in@ 233

Visit:

Last change on this file since 233 was 232, checked in by Herwig Bauernfeind, 17 years ago
Update 3.2 branch to 3.2.8
File size: 207.6 KB

Line
1	dnl Process this file with autoconf to produce a configure script.
2
3	dnl We must use autotools 2.54 or above
4	AC_PREREQ(2.54)
5
6	AC_INIT([Samba],[3],[[email protected]])
7
8	AC_CONFIG_SRCDIR([include/includes.h])
9	AC_CONFIG_HEADER(include/config.h)
10	AC_DEFINE(CONFIG_H_IS_FROM_SAMBA,1,[Marker for samba's config.h])
11
12	case "$PATH" in
13	/usr/ucb)
14	AC_MSG_WARN([\$PATH contains /usr/ucb - build errors may follow])
15	;;
16	esac
17
18	builddir=`pwd`
19	AC_SUBST(builddir)
20
21	m4_include(m4/samba_version.m4)
22	m4_include(m4/check_path.m4)
23
24	AC_LIBREPLACE_CC_CHECKS
25
26	m4_include(lib/talloc/libtalloc.m4)
27
28	TALLOC_OBJS=""
29	for obj in ${TALLOC_OBJ}; do
30	TALLOC_OBJS="${TALLOC_OBJS} ${tallocdir}/${obj}"
31	done
32	AC_SUBST(TALLOC_OBJS)
33
34	# TODO: These should come from m4_include(lib/tdb/libtdb.m4)
35	# but currently this fails: things have to get merged from s4.
36	tdbdir="lib/tdb"
37	AC_SUBST(tdbdir)
38	TDB_CFLAGS="-I${srcdir-.}/$tdbdir/include"
39	AC_SUBST(TDB_CFLAGS)
40	TDB_OBJ="common/tdb.o common/dump.o common/transaction.o common/error.o common/traverse.o"
41	TDB_OBJ="$TDB_OBJ common/freelist.o common/freelistcheck.o common/io.o common/lock.o common/open.o"
42	AC_SUBST(TDB_OBJ)
43
44	TDB_OBJS=""
45	for obj in ${TDB_OBJ}; do
46	TDB_OBJS="${TDB_OBJS} ${tdbdir}/${obj}"
47	done
48	AC_SUBST(TDB_OBJS)
49
50	SAMBA_CPPFLAGS="-Iinclude -I${srcdir-.}/include -I. -I${srcdir-.}"
51	SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} -I${srcdir-.}/lib/replace"
52	SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} ${TALLOC_CFLAGS}"
53	SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} ${TDB_CFLAGS}"
54	SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} -I${srcdir-.}/libaddns"
55	SAMBA_CPPFLAGS="${SAMBA_CPPFLAGS} -I${srcdir-.}/librpc"
56
57	SAMBA_CONFIGURE_CPPFLAGS="${SAMBA_CPPFLAGS} -I${srcdir-.}/popt"
58
59	## cleanup the $(srcdir) in the Makefile if we are outside of the tree
60	if test "x${srcdir-.}" != "x."; then
61	SAMBA_CPPFLAGS=`echo ${SAMBA_CPPFLAGS} \| sed -e "s;${srcdir};\$$srcdir$;g"`
62	fi
63
64	dnl Unique-to-Samba variables we'll be playing with.
65	AC_SUBST(SAMBA_CPPFLAGS)
66	AC_SUBST(SHELL)
67	AC_SUBST(LDSHFLAGS)
68	AC_SUBST(SONAMEFLAG)
69	AC_SUBST(SHLD)
70	AC_SUBST(MODULE_EXPORTS)
71	AC_SUBST(DSO_EXPORTS)
72	AC_SUBST(HOST_OS)
73	AC_SUBST(PICFLAG)
74	AC_SUBST(PIE_CFLAGS)
75	AC_SUBST(PIE_LDFLAGS)
76	AC_SUBST(RELRO_LDFLAGS)
77	AC_SUBST(SHLIBEXT)
78	AC_SUBST(INSTALLLIBCMD_SH)
79	AC_SUBST(INSTALLLIBCMD_A)
80	AC_SUBST(UNINSTALLLIBCMD_SH)
81	AC_SUBST(UNINSTALLLIBCMD_A)
82
83	AC_SUBST(INSTALL_LIBWBCLIENT)
84	AC_SUBST(UNINSTALL_LIBWBCLIENT)
85	AC_SUBST(LIBWBCLIENT_SHARED_TARGET)
86	AC_SUBST(LIBWBCLIENT_SHARED)
87	AC_SUBST(LIBWBCLIENT_STATIC_TARGET)
88	AC_SUBST(LIBWBCLIENT_STATIC)
89	AC_SUBST(LIBWBCLIENT_SOVER)
90	AC_SUBST(LIBWBCLIENT)
91	AC_SUBST(WINBIND_LIBS)
92
93	AC_SUBST(LIBSAMBAUTIL_SHARED)
94
95	AC_SUBST(PRINT_LIBS)
96	AC_SUBST(AUTH_LIBS)
97	AC_SUBST(ACL_LIBS)
98	AC_SUBST(PASSDB_LIBS)
99	AC_SUBST(IDMAP_LIBS)
100	AC_SUBST(KRB5_LIBS)
101	AC_SUBST(UUID_LIBS)
102	AC_SUBST(LDAP_LIBS)
103	AC_SUBST(PAM_MODULES)
104	AC_SUBST(INSTALL_PAM_MODULES)
105	AC_SUBST(UNINSTALL_PAM_MODULES)
106	AC_SUBST(NSS_MODULES)
107	AC_SUBST(EXTRA_BIN_PROGS)
108	AC_SUBST(CIFSMOUNT_PROGS)
109	AC_SUBST(INSTALL_CIFSMOUNT)
110	AC_SUBST(UNINSTALL_CIFSMOUNT)
111	AC_SUBST(CIFSUPCALL_PROGS)
112	AC_SUBST(INSTALL_CIFSUPCALL)
113	AC_SUBST(UNINSTALL_CIFSUPCALL)
114	AC_SUBST(EXTRA_SBIN_PROGS)
115	AC_SUBST(EXTRA_ALL_TARGETS)
116	AC_SUBST(CONFIG_LIBS)
117	AC_SUBST(NSCD_LIBS)
118
119	# compile with optimization and without debugging by default, but
120	# allow people to set their own preference.
121	# do this here since AC_CACHE_CHECK apparently sets the CFLAGS to "-g -O2"
122	# if it has no value. This prevent very large debug binaries from occurring
123	# by default.
124	if test "x$CFLAGS" = x; then
125	CFLAGS="-O"
126	fi
127	if test "x$debug" = "xyes" ; then
128	CFLAGS="${CFLAGS} -g"
129	else
130	CFLAGS="-O"
131	fi
132
133	CFLAGS="${CFLAGS} -D_SAMBA_BUILD_=3"
134
135	m4_include(lib/socket_wrapper/config.m4)
136	m4_include(lib/nss_wrapper/config.m4)
137
138	m4_include(m4/swat.m4)
139
140	# Probe the gcc version for extra CFLAGS. We always stash these in
141	# DEVELOPER_CFLAGS, so that you can turn them on and off with a simple
142	# Makefile edit, avoiding the need to re-run configure.
143	if test x"$ac_cv_prog_gcc" = x"yes" ; then
144	DEVELOPER_CFLAGS="-g -Wall -Wshadow -Wpointer-arith -Wcast-align -Wwrite-strings -DDEBUG_PASSWORD -DDEVELOPER"
145	# Add -Wdeclaration-after-statement if compiler supports it
146	AC_CACHE_CHECK(
147	[that the C compiler understands -Wdeclaration-after-statement],
148	samba_cv_HAVE_Wdeclaration_after_statement, [
149	AC_TRY_RUN_STRICT([
150	int main(void)
151	{
152	return 0;
153	}],[-Wdeclaration-after-statement],[$CPPFLAGS],[$LDFLAGS],
154	samba_cv_HAVE_Wdeclaration_after_statement=yes,
155	samba_cv_HAVE_Wdeclaration_after_statement=no,
156	samba_cv_HAVE_Wdeclaration_after_statement=cross)
157	])
158
159	if test x"$samba_cv_HAVE_Wdeclaration_after_statement" = x"yes"; then
160	DEVELOPER_CFLAGS="${DEVELOPER_CFLAGS} -Wdeclaration-after-statement"
161	fi
162
163	#-Werror-implicit-function-declaration
164	AC_CACHE_CHECK(
165	[that the C compiler understands -Werror-implicit-function-declaration],
166	samba_cv_HAVE_Werror_implicit_function_declaration, [
167	AC_TRY_RUN_STRICT([
168	int main(void)
169	{
170	return 0;
171	}],[-Werror-implicit-function-declaration],[$CPPFLAGS],[$LDFLAGS],
172	samba_cv_HAVE_Werror_implicit_function_declaration=yes,
173	samba_cv_HAVE_Werror_implicit_function_declaration=no,
174	samba_cv_HAVE_Werror_implicit_function_declaration=cross)
175	])
176	if test x"$samba_cv_HAVE_Werror_implicit_function_declaration" = x"yes"; then
177	DEVELOPER_CFLAGS="${DEVELOPER_CFLAGS} -Werror-implicit-function-declaration"
178	fi
179
180	# krb5developer is like developer, except we don't get
181	# -Wstrict-prototypes.
182	if test x"$krb5_developer" != x"$yes" ; then
183	DEVELOPER_CFLAGS="$DEVELOPER_CFLAGS -Wstrict-prototypes"
184	fi
185	fi
186
187	AC_ARG_ENABLE(dmalloc, [AS_HELP_STRING([--enable-dmalloc], [Enable heap debugging [default=no]])])
188
189	if test "x$enable_dmalloc" = xyes
190	then
191	AC_DEFINE(ENABLE_DMALLOC, 1, [Define to turn on dmalloc debugging])
192	AC_DEFINE(DMALLOC_FUNC_CHECK, 1,
193	[Define to check invariants around some common functions])
194	LIBS="$LIBS -ldmalloc"
195	fi
196
197	#################################################
198	# check for a shared memory profiling support
199	AC_MSG_CHECKING(whether to use profiling)
200	AC_ARG_WITH(profiling-data,
201	[AS_HELP_STRING([--with-profiling-data], [Include gathering source code profile information (default=no)])],
202	[ case "$withval" in
203	yes)
204	AC_MSG_RESULT(yes)
205	AC_DEFINE(WITH_PROFILE,1,[Whether to use profiling])
206	samba_cv_WITH_PROFILE=yes
207	;;
208	*)
209	AC_MSG_RESULT(no)
210	samba_cv_WITH_PROFILE=no
211	;;
212	esac ],
213	AC_MSG_RESULT(no)
214	)
215
216	dnl Checks for programs.
217
218	AC_PROG_INSTALL
219	AC_PROG_AWK
220	AC_PATH_PROG(PERL, perl)
221
222	AC_CHECK_TOOL(AR, ar)
223
224	dnl Check if we use GNU ld
225	LD=ld
226	AC_PROG_LD_GNU
227
228	dnl Certain versions of GNU ld the default is not to have the
229	dnl --allow-shlib-undefined flag defined. This causes a stackload of
230	dnl warnings when building modules.
231	if test "$ac_cv_prog_gnu_ld" = "yes"; then
232	ac_cv_gnu_ld_version=`$LD -v 2>/dev/null \| head -1`
233	AC_MSG_CHECKING(GNU ld release date)
234	changequote(,)dnl
235	ac_cv_gnu_ld_date=`echo $ac_cv_gnu_ld_version \| sed -n 's,^.$[2-9][0-9][0-9][0-9]$[-]$[01][0-9]$[-]$[0-3][0-9]$.$,\1\2\3,p'`
236	changequote([,])dnl
237	AC_MSG_RESULT(${ac_cv_gnu_ld_date})
238	if test -n "$ac_cv_gnu_ld_date"; then
239	if test "$ac_cv_gnu_ld_date" -lt 20030217; then
240	ac_cv_gnu_ld_no_default_allow_shlib_undefined=yes
241	fi
242	if test "$ac_cv_gnu_ld_date" -gt 20030101; then
243	ac_cv_gnu_ld_version_script=yes
244	fi
245	else
246	AC_MSG_CHECKING(GNU ld release version)
247	changequote(,)dnl
248	ac_cv_gnu_ld_vernr=`echo $ac_cv_gnu_ld_version \| sed -n 's,^.$[1-9][0-9]\.[0-9][0-9]$.$,\1,p'`
249	ac_cv_gnu_ld_vernr_major=`echo $ac_cv_gnu_ld_vernr \| cut -d '.' -f 1`
250	ac_cv_gnu_ld_vernr_minor=`echo $ac_cv_gnu_ld_vernr \| cut -d '.' -f 2`
251	changequote([,])dnl
252	AC_MSG_RESULT(${ac_cv_gnu_ld_vernr})
253	AC_MSG_CHECKING(GNU ld release version major)
254	AC_MSG_RESULT(${ac_cv_gnu_ld_vernr_major})
255	AC_MSG_CHECKING(GNU ld release version minor)
256	AC_MSG_RESULT(${ac_cv_gnu_ld_vernr_minor})
257	if test "$ac_cv_gnu_ld_vernr_major" -lt 2 \|\| test "$ac_cv_gnu_ld_vernr_minor" -lt 14; then
258	ac_cv_gnu_ld_no_default_allow_shlib_undefined=yes
259	fi
260	if test "$ac_cv_gnu_ld_vernr_major" -gt 2 \|\| test "$ac_cv_gnu_ld_vernr_major"=2 && test "$ac_cv_gnu_ld_vernr_minor" -ge 12; then
261	ac_cv_gnu_ld_version_script=yes
262	fi
263	fi
264	fi
265
266	dnl look for executable suffix
267	AC_EXEEXT
268
269	dnl Check if C compiler understands -c and -o at the same time
270	AC_PROG_CC_C_O
271	if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
272	BROKEN_CC=
273	else
274	BROKEN_CC=#
275	fi
276	AC_SUBST(BROKEN_CC)
277
278	dnl Check if the C compiler understands -Werror
279	AC_CACHE_CHECK([that the C compiler understands -Werror],samba_cv_HAVE_Werror, [
280	AC_TRY_RUN_STRICT([
281	int main(void)
282	{
283	return 0;
284	}],[-Werror],[$CPPFLAGS],[$LDFLAGS],
285	samba_cv_HAVE_Werror=yes,samba_cv_HAVE_Werror=no,samba_cv_HAVE_Werror=cross)])
286	if test x"$samba_cv_HAVE_Werror" = x"yes"; then
287	Werror_FLAGS="-Werror"
288	else
289	dnl Check if the C compiler understands -w2
290	AC_CACHE_CHECK([that the C compiler understands -w2],samba_cv_HAVE_w2, [
291	AC_TRY_RUN_STRICT([
292	int main(void)
293	{
294	return 0;
295	}],[-w2],[$CPPFLAGS],[$LDFLAGS],
296	samba_cv_HAVE_w2=yes,samba_cv_HAVE_w2=no,samba_cv_HAVE_w2=cross)])
297	if test x"$samba_cv_HAVE_w2" = x"yes"; then
298	Werror_FLAGS="-w2"
299	else
300	dnl Check if the C compiler understands -errwarn
301	AC_CACHE_CHECK([that the C compiler understands -errwarn],samba_cv_HAVE_errwarn, [
302	AC_TRY_RUN_STRICT([
303	int main(void)
304	{
305	return 0;
306	}],[-errwarn=%all],[$CPPFLAGS],[$LDFLAGS],
307	samba_cv_HAVE_errwarn=yes,samba_cv_HAVE_errwarn=no,samba_cv_HAVE_errwarn=cross)])
308	if test x"$samba_cv_HAVE_errwarn" = x"yes"; then
309	Werror_FLAGS="-errwarn=%all"
310	fi
311	fi
312	fi
313
314	dnl Check if the C compiler understands volatile (it should, being ANSI).
315	AC_CACHE_CHECK([that the C compiler understands volatile],samba_cv_volatile, [
316	AC_TRY_COMPILE([#include <sys/types.h>],[volatile int i = 0],
317	samba_cv_volatile=yes,samba_cv_volatile=no)])
318	if test x"$samba_cv_volatile" = x"yes"; then
319	AC_DEFINE(HAVE_VOLATILE, 1, [Whether the C compiler understands volatile])
320	fi
321
322	############################################
323	# check if the compiler can handle negative enum values
324	# and don't truncate the values to INT_MAX
325	# a runtime test is needed here
326	AC_SUBST(PIDL_ARGS)
327	AC_CACHE_CHECK([that the C compiler understands negative enum values],samba_cv_CC_NEGATIVE_ENUM_VALUES, [
328	AC_TRY_RUN(
329	[
330	#include <stdio.h>
331	enum negative_values { NEGATIVE_VALUE = 0xFFFFFFFF };
332	int main(void) {
333	enum negative_values v1 = NEGATIVE_VALUE;
334	unsigned v2 = NEGATIVE_VALUE;
335
336	if (v1 != 0xFFFFFFFF) {
337	printf("%u != 0xFFFFFFFF\n", v1);
338	return 1;
339	}
340	if (v2 != 0xFFFFFFFF) {
341	printf("%u != 0xFFFFFFFF\n", v2);
342	return 1;
343	}
344
345	return 0;
346	}
347	],
348	samba_cv_CC_NEGATIVE_ENUM_VALUES=yes,samba_cv__CC_NEGATIVE_ENUM_VALUES=no)])
349	if test x"$samba_cv_CC_NEGATIVE_ENUM_VALUES" != x"yes"; then
350	AC_MSG_WARN([using --unit-enums for pidl])
351	PIDL_ARGS="$PIDL_ARGS --uint-enums"
352	fi
353
354	dnl Figure out the flags to support named structure initializers
355
356	LIBREPLACE_C99_STRUCT_INIT([],[AC_MSG_ERROR([c99 structure initializer are not supported])])
357
358	UNAME_S=`(uname -s) 2>/dev/null` \|\| UNAME_S="unknown"
359	AC_MSG_CHECKING(uname -s)
360	AC_MSG_RESULT(${UNAME_S})
361
362	UNAME_R=`(uname -r) 2>/dev/null` \|\| UNAME_R="unknown"
363	AC_MSG_CHECKING(uname -r)
364	AC_MSG_RESULT(${UNAME_R})
365
366	UNAME_M=`(uname -m) 2>/dev/null` \|\| UNAME_M="unknown"
367	AC_MSG_CHECKING(uname -m)
368	AC_MSG_RESULT(${UNAME_M})
369
370	UNAME_P=`(uname -p) 2>/dev/null` \|\| UNAME_P="unknown"
371	AC_MSG_CHECKING(uname -p)
372	AC_MSG_RESULT(${UNAME_P})
373
374	UNAME_I=`(uname -i) 2>/dev/null` \|\| UNAME_I="unknown"
375	AC_MSG_CHECKING(uname -i)
376	AC_MSG_RESULT(${UNAME_I})
377
378	dnl Add #include for broken IRIX header files
379	case "$host_os" in
380	irix6)
381	#TODO add to libreplace
382	if test x"$ac_cv_prog_gcc" != x"yes" ; then
383	dnl Fix sensible defaults for MIPSPro compilers. The
384	dnl error numbers are valid for the 7.3 compilers,
385	dnl hopefully also valid for the 7.4 series.
386	dnl
387	dnl Bugzilla 3801. Force an error on warning 1035
388	dnl so we don't incorrectly detect stdint.h. This
389	dnl warning is emitted for #error directives.
390	CFLAGS="$CFLAGS -diag_error 1035"
391	dnl 1209: Controlling expression is constant
392	dnl 1174: Function foo declared but never referenced
393	dnl 3201: Parameter foo was never referenced
394	CFLAGS="$CFLAGS -woff 1209,1174,3201"
395	fi
396	;;
397	esac
398
399	DYNEXP=
400	AC_SUBST(DYNEXP)
401
402	dnl Add modules that have to be built by default here
403	dnl These have to be built static:
404	default_static_modules="pdb_smbpasswd pdb_tdbsam rpc_lsarpc rpc_samr rpc_winreg rpc_initshutdown rpc_dssetup rpc_wkssvc rpc_svcctl2 rpc_ntsvcs2 rpc_netlogon rpc_netdfs rpc_srvsvc rpc_spoolss rpc_eventlog2 auth_sam auth_unix auth_winbind auth_server auth_domain auth_builtin vfs_default nss_info_template"
405
406	dnl These are preferably build shared, and static if dlopen() is not available
407	default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_full_audit vfs_netatalk vfs_fake_perms vfs_default_quota vfs_readonly vfs_cap vfs_expand_msdfs vfs_shadow_copy vfs_shadow_copy2 charset_CP850 charset_CP437 auth_script vfs_readahead vfs_xattr_tdb vfs_streams_xattr vfs_streams_depot vfs_smb_traffic_analyzer"
408
409	if test "x$developer" = xyes; then
410	default_static_modules="$default_static_modules rpc_rpcecho"
411	default_shared_modules="$default_shared_modules charset_weird"
412	fi
413
414	#
415	# Config CPPFLAG settings for strange OS's that must be set
416	# before other tests. Do NOT invoke AC_CHECK_HEADERS within this
417	# case statement; its first reference must be unconditional.
418	#
419	case "$host_os" in
420	hpux)
421	#
422	# Defines needed for HPUX support.
423	# HPUX has bigcrypt but (sometimes?) doesn't use it for
424	# password hashing - hence the USE_BOTH_CRYPT_CALLS define.
425	#
426	case `uname -r` in
427	9\|10\|*11)
428	AC_DEFINE(USE_BOTH_CRYPT_CALLS, 1, [Whether to use both of HPUX' crypt calls])
429	;;
430	esac
431	;;
432
433	#
434	# CRAY Unicos has broken const handling
435	unicos)
436	AC_MSG_RESULT([disabling const])
437	CPPFLAGS="$CPPFLAGS -Dconst="
438	;;
439
440	#
441	# AIX4.x doesn't even admit to having large
442	# files at all unless the -D_LARGE_FILE or -D_LARGE_FILE_API flags are set.
443	#
444	aix4)
445	AC_MSG_RESULT([enabling large file support])
446	CPPFLAGS="$CPPFLAGS -D_LARGE_FILES"
447	AC_DEFINE(_LARGE_FILES, 1, [Whether to enable large file support])
448	;;
449	#
450	# Defines needed for Solaris 2.6/2.7 aka 7.0 to make it admit
451	# to the existance of large files..
452	# Note that -D_LARGEFILE64_SOURCE is different from the Sun
453	# recommendations on large file support, however it makes the
454	# compile work using gcc 2.7 and 2.8, whereas using the Sun
455	# recommendation makes the compile fail on gcc2.7. JRA.
456	#
457	# Solaris uses SYSV printing. Make sure to set that here. --jerry
458	#
459	solaris)
460	AC_DEFINE(SYSV, 1, [Whether to enable System V compatibility])
461	case `uname -r` in
462	5.0\|5.0.\|5.1\|5.1.\|5.2\|5.2.\|5.3\|5.3.\|5.5\|5.5.*)
463	AC_MSG_RESULT([no large file support])
464	;;
465	5.*)
466	AC_MSG_RESULT([enabling large file support])
467	if test "$ac_cv_prog_gcc" = yes; then
468	${CC-cc} -v >conftest.c 2>&1
469	ac_cv_gcc_compiler_version_number=`grep 'gcc version' conftest.c`
470	rm -fr conftest.c
471	case "$ac_cv_gcc_compiler_version_number" in
472	"gcc version 2.6"\|"gcc version 2.7")
473	CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE -D_REENTRANT"
474	LDFLAGS="$LDFLAGS -lthread"
475	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
476	;;
477	*)
478	CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE -D_REENTRANT -D_FILE_OFFSET_BITS=64"
479	LDFLAGS="$LDFLAGS -lthread"
480	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
481	AC_DEFINE(_FILE_OFFSET_BITS, 64, [File offset bits])
482	;;
483	esac
484	else
485	CPPFLAGS="$CPPFLAGS -D_LARGEFILE_SOURCE -D_REENTRANT -D_FILE_OFFSET_BITS=64"
486	LDFLAGS="$LDFLAGS -lthread"
487	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
488	AC_DEFINE(_FILE_OFFSET_BITS, 64, [File offset bits])
489	fi
490	;;
491	esac
492	;;
493	#
494	# IRIX uses SYSV printing. Make sure to set that here
495	#
496	irix)
497	AC_DEFINE(SYSV, 1, [Whether to enable System V compatibility])
498	;;
499	freebsd\|dragonfly)
500	AC_DEFINE(FREEBSD, 1, [Whether the host os is FreeBSD])
501	;;
502	#
503	# VOS may need to have POSIX support and System V compatibility enabled.
504	#
505	vos)
506	case "$CPPFLAGS" in
507	-D_POSIX_C_SOURCE)
508	;;
509	*)
510	CPPFLAGS="$CPPFLAGS -D_POSIX_C_SOURCE=200112L"
511	AC_DEFINE(_POSIX_C_SOURCE, 200112L, [Whether to enable POSIX support])
512	;;
513	esac
514	case "$CPPFLAGS" in
515	-D_SYSV\|-D_SVID_SOURCE)
516	;;
517	*)
518	CPPFLAGS="$CPPFLAGS -D_SYSV"
519	AC_DEFINE(_SYSV, 1, [Whether to enable System V compatibility])
520	esac
521	;;
522	#
523	# Tests needed for SINIX large file support.
524	#
525	sysv4)
526	if test $host = mips-sni-sysv4 ; then
527	AC_MSG_CHECKING([for LFS support])
528	old_CPPFLAGS="$CPPFLAGS"
529	CPPFLAGS="-D_LARGEFILE64_SOURCE $CPPFLAGS"
530	AC_TRY_RUN([
531	#include <unistd.h>
532	main () {
533	#if _LFS64_LARGEFILE == 1
534	exit(0);
535	#else
536	exit(1);
537	#endif
538	}], [SINIX_LFS_SUPPORT=yes], [SINIX_LFS_SUPPORT=no], [SINIX_LFS_SUPPORT=cross])
539	CPPFLAGS="$old_CPPFLAGS"
540	if test x$SINIX_LFS_SUPPORT = xyes ; then
541	CPPFLAGS="-D_LARGEFILE64_SOURCE $CPPFLAGS"
542	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
543	CFLAGS="`getconf LFS64_CFLAGS` $CFLAGS"
544	LDFLAGS="`getconf LFS64_LDFLAGS` $LDFLAGS"
545	LIBS="`getconf LFS64_LIBS` $LIBS"
546	fi
547	AC_MSG_RESULT([$SINIX_LFS_SUPPORT])
548	fi
549	;;
550
551	# Tests for linux LFS support. Need kernel 2.4 and glibc2.2 or greater support.
552	#
553	linux)
554	AC_MSG_CHECKING([for LFS support])
555	old_CPPFLAGS="$CPPFLAGS"
556	CPPFLAGS="-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE $CPPFLAGS"
557	AC_TRY_RUN([
558	#include <unistd.h>
559	#include <sys/utsname.h>
560	#include <string.h>
561	#include <stdlib.h>
562	main() {
563	#if _LFS64_LARGEFILE == 1
564	struct utsname uts;
565	char *release;
566	int major, minor;
567
568	/* Ensure this is glibc 2.2 or higher */
569	#if defined(__GLIBC__) && defined(__GLIBC_MINOR__)
570	int libc_major = __GLIBC__;
571	int libc_minor = __GLIBC_MINOR__;
572
573	if (libc_major < 2)
574	exit(1);
575	if (libc_minor < 2)
576	exit(1);
577	#endif
578
579	/* Ensure this is kernel 2.4 or higher */
580
581	uname(&uts);
582	release = strdup(uts.release);
583	major = atoi(strsep(&release, "."));
584	minor = atoi(strsep(&release, "."));
585
586	if (major > 2 \|\| (major == 2 && minor > 3))
587	exit(0);
588	exit(1);
589	#else
590	exit(1);
591	#endif
592	}
593	], [LINUX_LFS_SUPPORT=yes], [LINUX_LFS_SUPPORT=no], [LINUX_LFS_SUPPORT=cross])
594	CPPFLAGS="$old_CPPFLAGS"
595	if test x$LINUX_LFS_SUPPORT = xyes ; then
596	CPPFLAGS="-D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE $CPPFLAGS"
597	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
598	AC_DEFINE(_FILE_OFFSET_BITS, 64, [File offset bits])
599	AC_DEFINE(_GNU_SOURCE, 1, [Whether to use GNU libc extensions])
600	fi
601	AC_MSG_RESULT([$LINUX_LFS_SUPPORT])
602	;;
603
604	#
605	# MacOS X is the only system that uses compose character in utf8. This
606	# is so horribly broken....
607	#
608	darwin)
609	AC_DEFINE(BROKEN_UNICODE_COMPOSE_CHARACTERS, 1, [Does this system use unicode compose characters])
610
611	# Add a system specific charset module.
612	default_shared_modules="$default_shared_modules charset_macosxfs"
613
614	;;
615	hurd)
616	AC_MSG_CHECKING([for LFS support])
617	old_CPPFLAGS="$CPPFLAGS"
618	CPPFLAGS="-D_LARGEFILE64_SOURCE -D_GNU_SOURCE $CPPFLAGS"
619	AC_TRY_RUN([
620	#include <unistd.h>
621	main () {
622	#if _LFS64_LARGEFILE == 1
623	exit(0);
624	#else
625	exit(1);
626	#endif
627	}], [GLIBC_LFS_SUPPORT=yes], [GLIBC_LFS_SUPPORT=no], [GLIBC_LFS_SUPPORT=cross])
628	CPPFLAGS="$old_CPPFLAGS"
629	if test x$GLIBC_LFS_SUPPORT = xyes ; then
630	CPPFLAGS="-D_LARGEFILE64_SOURCE -D_GNU_SOURCE $CPPFLAGS"
631	AC_DEFINE(_LARGEFILE64_SOURCE, 1, [Whether to enable large file support])
632	AC_DEFINE(_GNU_SOURCE, 1, [Whether to use GNU libc extensions])
633	fi
634	AC_MSG_RESULT([$GLIBC_LFS_SUPPORT])
635	;;
636
637	esac
638
639	SAVE_CPPFLAGS="${CPPFLAGS}"
640	CPPFLAGS="${CPPFLAGS} ${SAMBA_CONFIGURE_CPPFLAGS}"
641
642	AC_LIBREPLACE_BROKEN_CHECKS
643	AC_LIBREPLACE_NETWORK_CHECKS
644
645	CPPFLAGS="${SAVE_CPPFLAGS}"
646
647	LIBREPLACE_DIR=`echo ${libreplacedir} \| sed -e "s;${srcdir};;" -e "s;^/;;"`
648
649	LIBREPLACE_OBJS=""
650	for obj in ${LIBREPLACEOBJ}; do
651	LIBREPLACE_OBJS="${LIBREPLACE_OBJS} ${LIBREPLACE_DIR}/${obj}"
652	done
653	AC_SUBST(LIBREPLACE_OBJS)
654
655	# add -ldl to the global LIBS
656	LIBS="${LIBS} ${LIBDL} ${LIBREPLACE_NETWORK_LIBS}"
657
658	AC_CHECK_HEADERS(aio.h sys/fcntl.h sys/select.h fcntl.h sys/time.h sys/unistd.h rpc/nettype.h)
659	AC_CHECK_HEADERS(unistd.h utime.h grp.h sys/id.h memory.h alloca.h)
660	AC_CHECK_HEADERS(limits.h float.h pthread.h)
661	AC_CHECK_HEADERS(rpc/rpc.h rpcsvc/nis.h rpcsvc/ypclnt.h)
662	AC_CHECK_HEADERS(sys/param.h ctype.h sys/wait.h sys/resource.h sys/ioctl.h sys/ipc.h sys/prctl.h)
663	AC_CHECK_HEADERS(sys/mman.h sys/filio.h sys/priv.h sys/shm.h string.h strings.h stdlib.h)
664	AC_CHECK_HEADERS(sys/mount.h sys/vfs.h sys/fs/s5param.h sys/filsys.h termios.h termio.h)
665	AC_CHECK_HEADERS(sys/termio.h sys/statfs.h sys/dustat.h sys/statvfs.h stdarg.h)
666	AC_CHECK_HEADERS(sys/sysmacros.h)
667	AC_CHECK_HEADERS(sys/syslog.h syslog.h)
668	AC_CHECK_HEADERS(langinfo.h locale.h)
669	AC_CHECK_HEADERS(xfs/libxfs.h)
670	AC_CHECK_HEADERS(netgroup.h)
671
672	AC_CHECK_HEADERS(rpcsvc/yp_prot.h,,,[[
673	#if HAVE_RPC_RPC_H
674	#include <rpc/rpc.h>
675	#endif
676	]])
677
678	## These fail to compile on IRIX so just check for their presence
679	AC_CHECK_HEADERS(sys/mode.h,,,)
680
681	# Look for Darwin headers
682	old_CPPFLAGS="$CPPFLAGS"
683	CPPFLAGS="-Iinclude $CPPFLAGS"
684	AC_CHECK_HEADERS([CoreFoundation/CFStringEncodingConverter.h], [], [AC_CHECK_HEADERS([CFStringEncodingConverter.h])])
685	CPPFLAGS="$old_CPPFLAGS"
686
687	# In valgrind 1.0.x, it's just valgrind.h. In 1.9.x+ there's a
688	# subdirectory of headers.
689	AC_CHECK_HEADERS(valgrind.h valgrind/valgrind.h valgrind/memcheck.h)
690
691	# check for linux on amd64 since valgrind is not quite there yet
692	case "$host_os" in
693	linux)
694	case "$UNAME_P" in
695	x86_64)
696	AC_DEFINE(HAVE_64BIT_LINUX,1,[Whether we are running on 64bit linux])
697	;;
698	esac
699	;;
700	esac
701
702
703	#
704	# HPUX has a bug in that including shadow.h causes a re-definition of MAXINT.
705	# This causes configure to fail to detect it. Check for shadow separately on HPUX.
706	#
707	case "$host_os" in
708	hpux)
709	AC_TRY_COMPILE([#include <shadow.h>],[struct spwd testme],
710	ac_cv_header_shadow_h=yes,ac_cv_header_shadow_h=no)
711	if test x"$ac_cv_header_shadow_h" = x"yes"; then
712	AC_DEFINE(HAVE_SHADOW_H,1,[Whether we have shadow.h])
713	fi
714	;;
715	esac
716	AC_CHECK_HEADERS(shadow.h)
717	AC_CHECK_HEADERS(nss.h nss_common.h nsswitch.h ns_api.h sys/security.h)
718	AC_CHECK_HEADERS(syscall.h sys/syscall.h)
719
720	AC_CHECK_HEADERS(sys/attributes.h attr/xattr.h sys/xattr.h sys/extattr.h sys/uio.h)
721	AC_CHECK_HEADERS(sys/ea.h sys/proplist.h)
722
723	AC_CHECK_HEADERS(sys/cdefs.h glob.h)
724
725	# For experimental utmp support (lastlog on some BSD-like systems)
726	AC_CHECK_HEADERS(utmp.h utmpx.h lastlog.h)
727
728	AC_CHECK_SIZEOF(int,cross)
729	AC_CHECK_SIZEOF(long,cross)
730	AC_CHECK_SIZEOF(long long,cross)
731	AC_CHECK_SIZEOF(short,cross)
732
733	AC_C_CONST
734	AC_C_INLINE
735	AC_C_BIGENDIAN
736	AC_C_CHAR_UNSIGNED
737
738	AC_TYPE_SIGNAL
739	AC_TYPE_UID_T
740	AC_TYPE_MODE_T
741	AC_TYPE_OFF_T
742	AC_TYPE_SIZE_T
743	AC_TYPE_PID_T
744	AC_STRUCT_ST_RDEV
745	AC_DIRENT_D_OFF
746	AC_CHECK_TYPE(ssize_t, int)
747	AC_CHECK_TYPE(wchar_t, unsigned short)
748
749	############################################
750	# for cups support we need libcups, and a handful of header files
751
752	AC_ARG_ENABLE(cups,
753	[AS_HELP_STRING([--enable-cups], [Turn on CUPS support (default=auto)])])
754
755	if test x$enable_cups != xno; then
756	AC_PATH_PROG(CUPS_CONFIG, cups-config)
757
758	if test "x$CUPS_CONFIG" != x; then
759
760	ac_save_CFLAGS=$CFLAGS
761	ac_save_LDFLAGS=$LDFLAGS
762	ac_save_PRINT_LIBS=$PRINT_LIBS
763	CFLAGS="$CFLAGS `$CUPS_CONFIG --cflags`"
764	LDFLAGS="$LDFLAGS `$CUPS_CONFIG --ldflags`"
765	PRINT_LIBS="$PRINT_LIBS `$CUPS_CONFIG --libs`"
766	AC_CHECK_HEADERS(cups/cups.h cups/language.h)
767	if test x"$ac_cv_header_cups_cups_h" = xyes -a \
768	x"$ac_cv_header_cups_language_h" = xyes; then
769	AC_DEFINE(HAVE_CUPS,1,[Whether we have CUPS])
770	samba_cv_HAVE_CUPS=yes
771	else
772	AC_MSG_WARN([cups-config around but cups-devel not installed])
773	CFLAGS=$ac_save_CFLAGS
774	LDFLAGS=$ac_save_LDFLAGS
775	PRINT_LIBS=$ac_save_PRINT_LIBS
776	fi
777
778	elif test x"$enable_cups" = x"yes"; then
779	AC_MSG_ERROR(Cups support required but cups-config not located. Make sure cups-devel related files are installed.)
780	fi
781	fi
782
783	AC_ARG_ENABLE(iprint,
784	[AS_HELP_STRING([--enable-iprint], [Turn on iPrint support (default=yes if cups is yes)])])
785
786	if test x$enable_iprint != xno; then
787	if test x"$samba_cv_HAVE_CUPS" = xyes; then
788	AC_DEFINE(HAVE_IPRINT,1,[Whether we have iPrint])
789	elif test x"$enable_iprint" = x"yes"; then
790	AC_MSG_ERROR(iPrint support required but cups not enabled. Make sure cups-devel related files are installed and that cups is enabled.)
791	fi
792	fi
793
794	############################################
795	# check if the compiler will optimize out function calls
796	AC_CACHE_CHECK([if the compiler will optimize out function calls],samba_cv_optimize_out_funcation_calls, [
797	AC_TRY_LINK([
798	#include <stdio.h>],
799	[
800	if (0) {
801	this_function_does_not_exist();
802	} else {
803	return 1;
804	}
805
806	],
807	samba_cv_optimize_out_funcation_calls=yes,samba_cv_optimize_out_funcation_calls=no)])
808	if test x"$samba_cv_optimize_out_funcation_calls" = x"yes"; then
809	AC_DEFINE(HAVE_COMPILER_WILL_OPTIMIZE_OUT_FNS,1,[Whether the compiler will optimize out function calls])
810	fi
811
812	#############################################
813	# check for fd passing struct via msg_control
814	AC_CACHE_CHECK([for fd passing via msg_control],samba_cv_msghdr_msg_control, [
815	AC_TRY_COMPILE([
816	#include <sys/types.h>
817	#include <stdlib.h>
818	#include <stddef.h>
819	#include <sys/socket.h>
820	#include <sys/un.h>],
821	[
822	struct msghdr msg;
823	union {
824	struct cmsghdr cm;
825	char control[CMSG_SPACE(sizeof(int))];
826	} control_un;
827	msg.msg_control = control_un.control;
828	msg.msg_controllen = sizeof(control_un.control);
829	],
830	samba_cv_msghdr_msg_control=yes,samba_cv_msghdr_msg_control=no)])
831	if test x"$samba_cv_msghdr_msg_control" = x"yes"; then
832	AC_DEFINE(HAVE_MSGHDR_MSG_CONTROL,1,
833	[If we can use msg_control for passing file descriptors])
834	fi
835
836	#############################################
837	# check for fd passing struct via msg_acctrights
838	AC_CACHE_CHECK([for fd passing via msg_acctrights],
839	samba_cv_msghdr_msg_acctrights, [
840	AC_TRY_COMPILE([
841	#include <sys/types.h>
842	#include <stdlib.h>
843	#include <stddef.h>
844	#include <sys/socket.h>
845	#include <sys/un.h>],
846	[
847	struct msghdr msg;
848	int fd;
849	msg.msg_acctrights = (caddr_t) &fd;
850	msg.msg_acctrightslen = sizeof(fd);
851	],
852	samba_cv_msghdr_msg_acctrights=yes,samba_cv_msghdr_msg_acctrights=no)])
853	if test x"$samba_cv_msghdr_msg_acctrights" = x"yes"; then
854	AC_DEFINE(HAVE_MSGHDR_MSG_ACCTRIGHTS,1,
855	[If we can use msg_acctrights for passing file descriptors])
856	fi
857
858	AC_CHECK_FUNCS(dirfd)
859	if test x"$ac_cv_func_dirfd" = x"yes"; then
860	default_shared_modules="$default_shared_modules vfs_syncops"
861	fi
862
863	AC_CACHE_CHECK([for sig_atomic_t type],samba_cv_sig_atomic_t, [
864	AC_TRY_COMPILE([
865	#include <sys/types.h>
866	#if STDC_HEADERS
867	#include <stdlib.h>
868	#include <stddef.h>
869	#endif
870	#include <signal.h>],[sig_atomic_t i = 0],
871	samba_cv_sig_atomic_t=yes,samba_cv_sig_atomic_t=no)])
872	if test x"$samba_cv_sig_atomic_t" = x"yes"; then
873	AC_DEFINE(HAVE_SIG_ATOMIC_T_TYPE,1,[Whether we have the atomic_t variable type])
874	fi
875
876	AC_CACHE_CHECK([for struct sigevent type],samba_cv_struct_sigevent, [
877	AC_TRY_COMPILE([
878	#include <sys/types.h>
879	#if STDC_HEADERS
880	#include <stdlib.h>
881	#include <stddef.h>
882	#endif
883	#include <signal.h>],[struct sigevent s;],
884	samba_cv_struct_sigevent=yes,samba_cv_struct_sigevent=no)])
885	if test x"$samba_cv_struct_sigevent" = x"yes"; then
886	AC_DEFINE(HAVE_STRUCT_SIGEVENT,1,[Whether we have the struct sigevent])
887	AC_CHECK_MEMBERS([struct sigevent.sigev_value.sival_ptr,struct sigevent.sigev_value.sigval_ptr], , ,
888	[#include <signal.h>])
889	fi
890
891	AC_CACHE_CHECK([for struct timespec type],samba_cv_struct_timespec, [
892	AC_TRY_COMPILE([
893	#include <sys/types.h>
894	#if STDC_HEADERS
895	#include <stdlib.h>
896	#include <stddef.h>
897	#endif
898	#if TIME_WITH_SYS_TIME
899	# include <sys/time.h>
900	# include <time.h>
901	#else
902	# if HAVE_SYS_TIME_H
903	# include <sys/time.h>
904	# else
905	# include <time.h>
906	# endif
907	#endif
908	],[struct timespec ts;],
909	samba_cv_struct_timespec=yes,samba_cv_struct_timespec=no)])
910	if test x"$samba_cv_struct_timespec" = x"yes"; then
911	AC_DEFINE(HAVE_STRUCT_TIMESPEC,1,[Whether we have struct timespec])
912	fi
913
914	# stupid headers have the functions but no declaration. grrrr.
915	AC_HAVE_DECL(errno, [#include <errno.h>])
916	AC_HAVE_DECL(setresuid, [#include <unistd.h>])
917	AC_HAVE_DECL(setresgid, [#include <unistd.h>])
918
919	# and glibc has setresuid under linux but the function does
920	# nothing until kernel 2.1.44! very dumb.
921	AC_CACHE_CHECK([for real setresuid],samba_cv_have_setresuid,[
922	AC_TRY_RUN([#include <errno.h>
923	main() { setresuid(1,1,1); setresuid(2,2,2); exit(errno==EPERM?0:1);}],
924	samba_cv_have_setresuid=yes,samba_cv_have_setresuid=no,samba_cv_have_setresuid=cross)])
925	if test x"$samba_cv_have_setresuid" = x"yes"; then
926	AC_DEFINE(HAVE_SETRESUID,1,[Whether the system has setresuid])
927	fi
928
929	# Do the same check for setresguid...
930	#
931	AC_CACHE_CHECK([for real setresgid],samba_cv_have_setresgid,[
932	AC_TRY_RUN([#include <unistd.h>
933	#include <errno.h>
934	main() { errno = 0; setresgid(1,1,1); exit(errno != 0 ? (errno==EPERM ? 0 : 1) : 0);}],
935	samba_cv_have_setresgid=yes,samba_cv_have_setresgid=no,samba_cv_have_setresgid=cross)])
936	if test x"$samba_cv_have_setresgid" = x"yes"; then
937	AC_DEFINE(HAVE_SETRESGID,1,[Whether the system has setresgid])
938	fi
939
940	AC_FUNC_MEMCMP
941
942	###############################################
943	# Readline included by default unless explicitly asked not to
944	test "${with_readline+set}" != "set" && with_readline=yes
945
946	# test for where we get readline() from
947	AC_MSG_CHECKING(whether to use readline)
948	AC_ARG_WITH(readline,
949	[AS_HELP_STRING([--with-readline[=DIR]], [Look for readline include/libs in DIR (default=auto)])],
950	[ case "$with_readline" in
951	yes)
952	AC_MSG_RESULT(yes)
953
954	AC_CHECK_HEADERS(readline.h history.h readline/readline.h)
955	AC_CHECK_HEADERS(readline/history.h)
956
957	AC_CHECK_HEADERS(readline.h readline/readline.h,[
958	for termlib in ncurses curses termcap terminfo termlib tinfo; do
959	AC_CHECK_LIB(${termlib}, tgetent, [TERMLIBS="-l${termlib}"; break])
960	done
961	AC_CHECK_LIB(readline, rl_callback_handler_install,
962	[TERMLIBS="-lreadline $TERMLIBS"
963	AC_DEFINE(HAVE_LIBREADLINE,1,[Whether the system has readline])
964	break], [TERMLIBS=], $TERMLIBS)])
965	;;
966	no)
967	AC_MSG_RESULT(no)
968	;;
969	*)
970	AC_MSG_RESULT(yes)
971
972	# Needed for AC_CHECK_HEADERS and AC_CHECK_LIB to look at
973	# alternate readline path
974	_ldflags=${LDFLAGS}
975	_cppflags=${CPPFLAGS}
976
977	# Add additional search path
978	LDFLAGS="-L$with_readline/lib $LDFLAGS"
979	CPPFLAGS="-I$with_readline/include $CPPFLAGS"
980
981	AC_CHECK_HEADERS(readline.h history.h readline/readline.h)
982	AC_CHECK_HEADERS(readline/history.h)
983
984	AC_CHECK_HEADERS(readline.h readline/readline.h,[
985	for termlib in ncurses curses termcap terminfo termlib; do
986	AC_CHECK_LIB(${termlib}, tgetent, [TERMLIBS="-l${termlib}"; break])
987	done
988	AC_CHECK_LIB(readline, rl_callback_handler_install,
989	[TERMLDFLAGS="-L$with_readline/lib"
990	TERMCPPFLAGS="-I$with_readline/include"
991	CPPFLAGS="-I$with_readline/include $CPPFLAGS"
992	TERMLIBS="-lreadline $TERMLIBS"
993	AC_DEFINE(HAVE_LIBREADLINE,1,[Whether the system has readline])
994	break], [TERMLIBS= CPPFLAGS=$_cppflags], $TERMLIBS)])
995
996	LDFLAGS=$_ldflags
997	;;
998	esac],
999	AC_MSG_RESULT(no)
1000	)
1001	AC_SUBST(TERMLIBS)
1002	AC_SUBST(TERMLDFLAGS)
1003
1004	# The readline API changed slightly from readline3 to readline4, so
1005	# code will generate warnings on one of them unless we have a few
1006	# special cases.
1007	AC_CHECK_LIB(readline, rl_completion_matches,
1008	[AC_DEFINE(HAVE_NEW_LIBREADLINE, 1,
1009	[Do we have rl_completion_matches?])],
1010	[],
1011	[$TERMLIBS])
1012
1013	# not all readline libs have rl_event_hook or history_list
1014	AC_CHECK_DECLS(rl_event_hook, [], [], [#include <readline/readline.h>])
1015	AC_CHECK_LIB(readline, history_list,
1016	[AC_DEFINE(HAVE_HISTORY_LIST, 1, [Do we have history_list?])],
1017	[],
1018	[$TERMLIBS])
1019
1020	###############################################
1021	# test for where we get yp_get_default_domain() from
1022	AC_SEARCH_LIBS(yp_get_default_domain, [nsl])
1023	AC_CHECK_FUNCS(yp_get_default_domain)
1024
1025	# Check if we have execl, if not we need to compile smbrun.
1026	AC_CHECK_FUNCS(execl)
1027	if test x"$ac_cv_func_execl" = x"no"; then
1028	EXTRA_BIN_PROGS="$EXTRA_BIN_PROGS bin/smbrun\$(EXEEXT)"
1029	fi
1030
1031	AC_CHECK_FUNCS(waitpid getcwd strdup strndup strnlen strerror chown fchown lchown chmod fchmod chroot link mknod mknod64)
1032	AC_CHECK_FUNCS(strtol strtoll strtoul strtoull strtouq __strtoull)
1033	AC_CHECK_FUNCS(fstat strchr utime utimes chflags)
1034	AC_CHECK_FUNCS(getrlimit fsync fdatasync memset strlcpy strlcat setpgid)
1035	AC_CHECK_FUNCS(memmove setsid glob strpbrk pipe crypt16 getauthuid)
1036	AC_CHECK_FUNCS(strftime sigprocmask sigblock sigaction sigset innetgr setnetgrent getnetgrent endnetgrent)
1037	AC_CHECK_FUNCS(initgroups select poll rdchk getgrnam getgrent pathconf realpath)
1038	AC_CHECK_FUNCS(setpriv setgidx setuidx setgroups sysconf mktime rename ftruncate chsize stat64 fstat64)
1039	AC_CHECK_FUNCS(lstat64 fopen64 atexit grantpt dup2 lseek64 ftruncate64)
1040	AC_CHECK_FUNCS(fseek64 fseeko64 ftell64 ftello64 setluid getpwanam setlinebuf)
1041	AC_CHECK_FUNCS(opendir64 readdir64 seekdir64 telldir64 rewinddir64 closedir64)
1042	AC_CHECK_FUNCS(getpwent_r)
1043	AC_CHECK_FUNCS(getdents getdents64)
1044	AC_CHECK_FUNCS(srandom random srand rand setenv usleep strcasecmp fcvt fcvtl symlink readlink)
1045	AC_CHECK_FUNCS(syslog vsyslog timegm)
1046	AC_CHECK_FUNCS(setlocale nl_langinfo)
1047	AC_CHECK_FUNCS(nanosleep)
1048	AC_CHECK_FUNCS(mlock munlock mlockall munlockall)
1049	AC_CHECK_FUNCS(memalign posix_memalign hstrerror)
1050	AC_CHECK_HEADERS(sys/mman.h)
1051	# setbuffer, shmget, shm_open are needed for smbtorture
1052	AC_CHECK_FUNCS(setbuffer shmget shm_open)
1053
1054	# Find a method of generating a stack trace
1055	AC_CHECK_HEADERS(execinfo.h libexc.h libunwind.h)
1056	# libexecinfo provides backtrace_symbols on FreeBSD
1057	AC_SEARCH_LIBS(backtrace_symbols, [execinfo])
1058	AC_CHECK_FUNCS(backtrace_symbols)
1059	AC_CHECK_LIB(exc, trace_back_stack)
1060
1061	printf "%s" "checking for GPFS GPL libs... "
1062	save_LIBS="$LIBS"
1063	LIBS="$LIBS -lgpfs_gpl"
1064	AC_TRY_LINK([#include <gpfs_gpl.h>],
1065	[gpfs_set_share(0,GPFS_SHARE_READ,GPFS_DENY_NONE)],
1066	samba_cv_HAVE_GPFS=yes,
1067	samba_cv_HAVE_GPFS=no)
1068	echo $samba_cv_HAVE_GPFS
1069	if test x"$samba_cv_HAVE_GPFS" = x"yes"; then
1070	AC_DEFINE(HAVE_GPFS,1,[Whether GPFS GPL libs are available])
1071	default_shared_modules="$default_shared_modules vfs_gpfs"
1072	fi
1073	LIBS="$save_LIBS"
1074
1075	# Note that all the libunwind symbols in the API are defined to internal
1076	# platform-specific version, so we must include libunwind.h before checking
1077	# any of them.
1078	AC_MSG_CHECKING([for libunwind])
1079	save_LIBS=$LIBS
1080
1081	UNWIND_ARCH="unknown"
1082	if test x"$UNAME_I" != x"unknown"; then
1083	UNWIND_ARCH="$UNAME_I"
1084	elif test x"$UNAME_M" != x"unknown"; then
1085	UNWIND_ARCH="$UNAME_M"
1086	elif test x"$UNAME_P" != x"unknown"; then
1087	UNWIND_ARCH="$UNAME_P"
1088	fi
1089
1090	case "$UNWIND_ARCH" in
1091	unknown)
1092	# This probably won't link without
1093	# the platform-specific libunwind.
1094	LIBS="$LIBS -lunwind"
1095	;;
1096	i386\|i586\|i686)
1097	# Add the platform-specific libunwind module.
1098	LIBS="$LIBS -lunwind -lunwind-x86"
1099	;;
1100	*)
1101	# Add the platform-specific libunwind module.
1102	# based on uname -i, uname -m or uname -p
1103	LIBS="$LIBS -lunwind -lunwind-$UNWIND_ARCH"
1104	;;
1105	esac
1106
1107	AC_TRY_LINK(
1108	[
1109	#ifdef HAVE_LIBUNWIND_H
1110	#include <libunwind.h>
1111	#endif
1112	],
1113	[
1114	unw_context_t ctx; unw_cursor_t cur;
1115	char buf[256]; unw_word_t off;
1116	unw_getcontext(&ctx); unw_init_local(&cur, &ctx);
1117	unw_get_proc_name(&cur, buf, sizeof(buf), &off);
1118	],
1119	[
1120	AC_MSG_RESULT(yes)
1121	AC_DEFINE(HAVE_LIBUNWIND, 1, [Whether libunwind is available])
1122
1123	# If we have libunwind, test whether we also have libunwind-ptrace
1124	# which would let us unwind arbitrary processes.
1125	save_LIBS=$LIBS
1126	AC_CHECK_HEADERS(libunwind-ptrace.h)
1127	AC_CHECK_LIB(unwind-ptrace, _UPT_create,
1128	[
1129	LIBUNWIND_PTRACE="-lunwind-ptrace";
1130	AC_DEFINE(HAVE_LIBUNWIND_PTRACE, 1,
1131	[Whether libunwind-ptrace.a is available.])
1132	],
1133	[ LIBUNWIND_PTRACE="" ])
1134
1135	LIBS=$save_LIBS
1136	],
1137	[
1138	AC_MSG_RESULT(no)
1139	LIBS=$save_LIBS
1140	])
1141
1142	# To use libunwind-ptrace, we also need to make some ptrace system calls.
1143	if test x"$LIBUNWIND_PTRACE" != x"" ; then
1144	AC_CHECK_HEADERS(sys/ptrace.h)
1145	AC_MSG_CHECKING([for the Linux ptrace(2) interface])
1146	AC_TRY_LINK(
1147	[
1148	#if HAVE_SYS_TYPES_H
1149	#include <sys/types.h>
1150	#endif
1151	#if HAVE_SYS_PTRACE_H
1152	#include <sys/ptrace.h>
1153	#endif
1154	],
1155	[
1156	int main(int argc, const char ** argv)
1157	{
1158	pid_t me = (pid_t)-1;
1159	ptrace(PTRACE_ATTACH, me, 0, 0);
1160	ptrace(PTRACE_DETACH, me, 0, 0);
1161	return 0;
1162	}
1163	],
1164	[
1165	AC_MSG_RESULT(yes)
1166	AC_DEFINE(HAVE_LINUX_PTRACE, 1,
1167	[Whether the Linux ptrace(2) interface is available.])
1168	],
1169	[
1170	AC_MSG_RESULT(no)
1171	LIBUNWIND_PTRACE=""
1172	])
1173	fi
1174
1175	AC_SUBST(LIBUNWIND_PTRACE)
1176
1177	AC_CHECK_FUNCS(_dup _dup2 _opendir _readdir _seekdir _telldir _closedir)
1178	AC_CHECK_FUNCS(__dup __dup2 __opendir __readdir __seekdir __telldir __closedir)
1179	AC_CHECK_FUNCS(__getcwd _getcwd)
1180	AC_CHECK_FUNCS(__xstat __fxstat __lxstat)
1181	AC_CHECK_FUNCS(_stat _lstat _fstat __stat __lstat __fstat)
1182	AC_CHECK_FUNCS(_acl __acl _facl __facl _open __open _chdir __chdir)
1183	AC_CHECK_FUNCS(_close __close _fchdir __fchdir _fcntl __fcntl)
1184	AC_CHECK_FUNCS(getdents __getdents _lseek __lseek _read __read)
1185	AC_CHECK_FUNCS(getdirentries _write __write _fork __fork)
1186	AC_CHECK_FUNCS(_stat64 __stat64 _fstat64 __fstat64 _lstat64 __lstat64)
1187	AC_CHECK_FUNCS(__sys_llseek llseek _llseek __llseek readdir64 _readdir64 __readdir64)
1188	AC_CHECK_FUNCS(pread _pread __pread pread64 _pread64 __pread64)
1189	AC_CHECK_FUNCS(pwrite _pwrite __pwrite pwrite64 _pwrite64 __pwrite64)
1190	AC_CHECK_FUNCS(open64 _open64 __open64 creat64)
1191	AC_CHECK_FUNCS(prctl)
1192
1193	AC_TRY_COMPILE([
1194	#ifdef HAVE_SYS_PRCTL_H
1195	#include <sys/prctl.h>
1196	#endif
1197	],
1198	[int i; i = prtcl(0); ],
1199	AC_DEFINE(HAVE_PRCTL, 1, [Whether prctl is available]),[])
1200
1201	#
1202	#
1203	#
1204	case "$host_os" in
1205	linux)
1206	# glibc <= 2.3.2 has a broken getgrouplist
1207	AC_TRY_RUN([
1208	#include <unistd.h>
1209	#include <sys/utsname.h>
1210	main() {
1211	/* glibc up to 2.3 has a broken getgrouplist */
1212	#if defined(__GLIBC__) && defined(__GLIBC_MINOR__)
1213	int libc_major = __GLIBC__;
1214	int libc_minor = __GLIBC_MINOR__;
1215
1216	if (libc_major < 2)
1217	exit(1);
1218	if ((libc_major == 2) && (libc_minor <= 3))
1219	exit(1);
1220	#endif
1221	exit(0);
1222	}
1223	], [linux_getgrouplist_ok=yes], [linux_getgrouplist_ok=no])
1224	if test x"$linux_getgrouplist_ok" = x"yes"; then
1225	AC_DEFINE(HAVE_GETGROUPLIST, 1, [Have good getgrouplist])
1226	fi
1227	;;
1228	*)
1229	AC_CHECK_FUNCS(getgrouplist)
1230	;;
1231	esac
1232
1233	#
1234	# stat64 family may need <sys/stat.h> on some systems, notably ReliantUNIX
1235	#
1236
1237	if test x$ac_cv_func_stat64 = xno ; then
1238	AC_MSG_CHECKING([for stat64 in <sys/stat.h>])
1239	AC_TRY_LINK([
1240	#if defined(HAVE_UNISTD_H)
1241	#include <unistd.h>
1242	#endif
1243	#include <sys/stat.h>
1244	], [struct stat64 st64; exit(stat64(".",&st64));], [ac_cv_func_stat64=yes])
1245	AC_MSG_RESULT([$ac_cv_func_stat64])
1246	if test x$ac_cv_func_stat64 = xyes ; then
1247	AC_DEFINE(HAVE_STAT64,1,[Whether stat64() is available])
1248	fi
1249	fi
1250
1251	if test x$ac_cv_func_lstat64 = xno ; then
1252	AC_MSG_CHECKING([for lstat64 in <sys/stat.h>])
1253	AC_TRY_LINK([
1254	#if defined(HAVE_UNISTD_H)
1255	#include <unistd.h>
1256	#endif
1257	#include <sys/stat.h>
1258	], [struct stat64 st64; exit(lstat64(".",&st64));], [ac_cv_func_lstat64=yes])
1259	AC_MSG_RESULT([$ac_cv_func_lstat64])
1260	if test x$ac_cv_func_lstat64 = xyes ; then
1261	AC_DEFINE(HAVE_LSTAT64,[Whether lstat64() is available])
1262	fi
1263	fi
1264
1265	if test x$ac_cv_func_fstat64 = xno ; then
1266	AC_MSG_CHECKING([for fstat64 in <sys/stat.h>])
1267	AC_TRY_LINK([
1268	#if defined(HAVE_UNISTD_H)
1269	#include <unistd.h>
1270	#endif
1271	#include <sys/stat.h>
1272	], [struct stat64 st64; exit(fstat64(0,&st64));], [ac_cv_func_fstat64=yes])
1273	AC_MSG_RESULT([$ac_cv_func_fstat64])
1274	if test x$ac_cv_func_fstat64 = xyes ; then
1275	AC_DEFINE(HAVE_FSTAT64,1,[Whether fstat64() is available])
1276	fi
1277	fi
1278
1279	#################################################
1280	# Check whether struct stat has timestamps with sub-second resolution.
1281	# At least IRIX and Solaris have these. FREEBSD does as well,
1282	# but with different members
1283	#
1284	# We check that
1285	# all of st_mtim, st_atim and st_ctim exist
1286	# all of the members are in fact of type struct timespec
1287	#
1288	# There is some conflicting standards weirdness about whether we should use
1289	# "struct timespec" or "timespec_t". Linux doesn't have timespec_t, so we
1290	# prefer struct timespec.
1291	AC_CACHE_CHECK([whether struct stat has timespec timestamps],
1292	samba_cv_stat_timespec_hires,
1293	[
1294	AC_TRY_COMPILE(
1295	[
1296	#if TIME_WITH_SYS_TIME
1297	# include <sys/time.h>
1298	# include <time.h>
1299	#else
1300	# if HAVE_SYS_TIME_H
1301	# include <sys/time.h>
1302	# else
1303	# include <time.h>
1304	# endif
1305	#endif
1306	#ifdef HAVE_SYS_STAT_H
1307	#include <sys/stat.h>
1308	#endif
1309	],
1310	[
1311	struct timespec t;
1312	struct stat s = {0};
1313	t = s.st_mtimespec;
1314	t = s.st_ctimespec;
1315	t = s.st_atimespec;
1316	],
1317	samba_cv_stat_timespec_hires=yes, samba_cv_stat_timespec_hires=no)
1318	])
1319
1320	if test x"$samba_cv_stat_timespec_hires" = x"yes" ; then
1321	AC_DEFINE(HAVE_STAT_ST_MTIMESPEC, 1, [whether struct stat contains st_mtimepec])
1322	AC_DEFINE(HAVE_STAT_ST_ATIMESPEC, 1, [whether struct stat contains st_atimespec])
1323	AC_DEFINE(HAVE_STAT_ST_CTIMESPEC, 1, [whether struct stat contains st_ctimespec])
1324	AC_DEFINE(HAVE_STAT_HIRES_TIMESTAMPS, 1, [whether struct stat has sub-second timestamps])
1325	fi
1326
1327
1328
1329	AC_CACHE_CHECK([whether struct stat has sub-second timestamps], samba_cv_stat_hires,
1330	[
1331	AC_TRY_COMPILE(
1332	[
1333	#if TIME_WITH_SYS_TIME
1334	# include <sys/time.h>
1335	# include <time.h>
1336	#else
1337	# if HAVE_SYS_TIME_H
1338	# include <sys/time.h>
1339	# else
1340	# include <time.h>
1341	# endif
1342	#endif
1343	#ifdef HAVE_SYS_STAT_H
1344	#include <sys/stat.h>
1345	#endif
1346	],
1347	[
1348	struct timespec t;
1349	struct stat s = {0};
1350	t.tv_sec = s.st_mtim.tv_sec;
1351	t.tv_nsec = s.st_mtim.tv_nsec;
1352	t.tv_sec = s.st_ctim.tv_sec;
1353	t.tv_nsec = s.st_ctim.tv_nsec;
1354	t.tv_sec = s.st_atim.tv_sec;
1355	t.tv_nsec = s.st_atim.tv_nsec;
1356	],
1357	samba_cv_stat_hires=yes, samba_cv_stat_hires=no)
1358	])
1359
1360	if test x"$samba_cv_stat_hires" = x"yes" ; then
1361	AC_DEFINE(HAVE_STAT_ST_MTIM, 1, [whether struct stat contains st_mtim])
1362	AC_DEFINE(HAVE_STAT_ST_ATIM, 1, [whether struct stat contains st_atim])
1363	AC_DEFINE(HAVE_STAT_ST_CTIM, 1, [whether struct stat contains st_ctim])
1364	AC_DEFINE(HAVE_STAT_HIRES_TIMESTAMPS, 1,
1365	[whether struct stat has sub-second timestamps])
1366	fi
1367
1368	AC_CACHE_CHECK([whether struct stat has sub-second timestamps without struct timespec suffixed nsec], samba_cv_stat_hires_notimespec,
1369	[
1370	AC_TRY_COMPILE(
1371	[
1372	#if TIME_WITH_SYS_TIME
1373	# include <sys/time.h>
1374	# include <time.h>
1375	#else
1376	# if HAVE_SYS_TIME_H
1377	# include <sys/time.h>
1378	# else
1379	# include <time.h>
1380	# endif
1381	#endif
1382	#ifdef HAVE_SYS_STAT_H
1383	#include <sys/stat.h>
1384	#endif
1385	],
1386	[
1387	struct timespec t;
1388	struct stat s = {0};
1389	t.tv_sec = s.st_mtime;
1390	t.tv_nsec = s.st_mtimensec;
1391	t.tv_sec = s.st_ctime;
1392	t.tv_nsec = s.st_ctimensec;
1393	t.tv_sec = s.st_atime;
1394	t.tv_nsec = s.st_atimensec;
1395	],
1396	samba_cv_stat_hires_notimespec=yes, samba_cv_stat_hires_notimespec=no)
1397	])
1398
1399	if test x"$samba_cv_stat_hires_notimespec" = x"yes" ; then
1400	AC_DEFINE(HAVE_STAT_ST_MTIMENSEC, 1, [whether struct stat contains st_mtimensec])
1401	AC_DEFINE(HAVE_STAT_ST_ATIMENSEC, 1, [whether struct stat contains st_atimensec])
1402	AC_DEFINE(HAVE_STAT_ST_CTIMENSEC, 1, [whether struct stat contains st_ctimensec])
1403	AC_DEFINE(HAVE_STAT_HIRES_TIMESTAMPS, 1,
1404	[whether struct stat has sub-second timestamps without struct timespec suffixed nsec])
1405	fi
1406
1407	dnl AIX stype sub-second timestamps:
1408	AC_CACHE_CHECK([whether struct stat has sub-second timestamps without struct timespec suffixed _n], samba_cv_stat_hires_notimespec_n,
1409	[
1410	AC_TRY_COMPILE(
1411	[
1412	#if TIME_WITH_SYS_TIME
1413	# include <sys/time.h>
1414	# include <time.h>
1415	#else
1416	# if HAVE_SYS_TIME_H
1417	# include <sys/time.h>
1418	# else
1419	# include <time.h>
1420	# endif
1421	#endif
1422	#ifdef HAVE_SYS_STAT_H
1423	#include <sys/stat.h>
1424	#endif
1425	],
1426	[
1427	struct timespec t;
1428	struct stat s = {0};
1429	t.tv_sec = s.st_mtime;
1430	t.tv_nsec = s.st_mtime_n;
1431	t.tv_sec = s.st_ctime;
1432	t.tv_nsec = s.st_ctime_n;
1433	t.tv_sec = s.st_atime;
1434	t.tv_nsec = s.st_atime_n;
1435	],
1436	samba_cv_stat_hires_notimespec_n=yes, samba_cv_stat_hires_notimespec_n=no)
1437	])
1438
1439	if test x"$samba_cv_stat_hires_notimespec_n" = x"yes" ; then
1440	AC_DEFINE(HAVE_STAT_ST_MTIME_N, 1, [whether struct stat contains st_mtime_n])
1441	AC_DEFINE(HAVE_STAT_ST_ATIME_N, 1, [whether struct stat contains st_atime_n])
1442	AC_DEFINE(HAVE_STAT_ST_CTIME_N, 1, [whether struct stat contains st_ctime_n])
1443	AC_DEFINE(HAVE_STAT_HIRES_TIMESTAMPS, 1,
1444	[whether struct stat has sub-second timestamps without struct timespec suffixed _n])
1445	fi
1446
1447	dnl Tru64 has _micro_second_ resolution:
1448	AC_CACHE_CHECK([whether struct stat has sub-second timestamps in st_uXtime], samba_cv_stat_hires_uxtime,
1449	[
1450	AC_TRY_COMPILE(
1451	[
1452	#if TIME_WITH_SYS_TIME
1453	# include <sys/time.h>
1454	# include <time.h>
1455	#else
1456	# if HAVE_SYS_TIME_H
1457	# include <sys/time.h>
1458	# else
1459	# include <time.h>
1460	# endif
1461	#endif
1462	#ifdef HAVE_SYS_STAT_H
1463	#include <sys/stat.h>
1464	#endif
1465	],
1466	[
1467	struct timespec t;
1468	struct stat s = {0};
1469	t.tv_sec = s.st_mtime;
1470	t.tv_nsec = s.st_umtime * 1000;
1471	t.tv_sec = s.st_ctime;
1472	t.tv_nsec = s.st_uctime * 1000;
1473	t.tv_sec = s.st_atime;
1474	t.tv_nsec = s.st_uatime * 1000;
1475	],
1476	samba_cv_stat_hires_uxtime=yes, samba_cv_stat_hires_uxtime=no)
1477	])
1478
1479	if test x"$samba_cv_stat_hires_uxtime" = x"yes" ; then
1480	AC_DEFINE(HAVE_STAT_ST_UMTIME, 1, [whether struct stat contains st_umtime])
1481	AC_DEFINE(HAVE_STAT_ST_UATIME, 1, [whether struct stat contains st_uatime])
1482	AC_DEFINE(HAVE_STAT_ST_UCTIME, 1, [whether struct stat contains st_uctime])
1483	AC_DEFINE(HAVE_STAT_HIRES_TIMESTAMPS, 1,
1484	[whether struct stat has sub-second timestamps in st_uXtime])
1485	fi
1486
1487	AC_CACHE_CHECK([whether struct stat has st_birthtimespec], samba_cv_stat_st_birthtimespec,
1488	[
1489	AC_TRY_COMPILE(
1490	[
1491	#if TIME_WITH_SYS_TIME
1492	# include <sys/time.h>
1493	# include <time.h>
1494	#else
1495	# if HAVE_SYS_TIME_H
1496	# include <sys/time.h>
1497	# else
1498	# include <time.h>
1499	# endif
1500	#endif
1501	#ifdef HAVE_SYS_STAT_H
1502	#include <sys/stat.h>
1503	#endif
1504	],
1505	[
1506	struct timespec t;
1507	struct stat s = {0};
1508	t = s.st_birthtimespec;
1509	],
1510	samba_cv_stat_st_birthtimespec=yes, samba_cv_stat_st_birthtimespec=no)
1511	])
1512
1513	if test x"$samba_cv_stat_st_birthtimespec" = x"yes" ; then
1514	AC_DEFINE(HAVE_STAT_ST_BIRTHTIMESPEC, 1, [whether struct stat contains st_birthtimespec])
1515	fi
1516
1517	AC_CACHE_CHECK([whether struct stat has st_birthtimensec], samba_cv_stat_st_birthtimensec,
1518	[
1519	AC_TRY_COMPILE(
1520	[
1521	#if TIME_WITH_SYS_TIME
1522	# include <sys/time.h>
1523	# include <time.h>
1524	#else
1525	# if HAVE_SYS_TIME_H
1526	# include <sys/time.h>
1527	# else
1528	# include <time.h>
1529	# endif
1530	#endif
1531	#ifdef HAVE_SYS_STAT_H
1532	#include <sys/stat.h>
1533	#endif
1534	],
1535	[
1536	struct timespec t;
1537	struct stat s = {0};
1538	t.tv_nsec = s.st_birthtimensec;
1539	],
1540	samba_cv_stat_st_birthtimensec=yes, samba_cv_stat_st_birthtimensec=no)
1541	])
1542
1543	if test x"$samba_cv_stat_st_birthtimensec" = x"yes" ; then
1544	AC_DEFINE(HAVE_STAT_ST_BIRTHTIMENSEC, 1, [whether struct stat contains st_birthtimensec])
1545	fi
1546
1547	AC_CACHE_CHECK([whether struct stat has st_birthtime], samba_cv_stat_st_birthtime,
1548	[
1549	AC_TRY_COMPILE(
1550	[
1551	#if TIME_WITH_SYS_TIME
1552	# include <sys/time.h>
1553	# include <time.h>
1554	#else
1555	# if HAVE_SYS_TIME_H
1556	# include <sys/time.h>
1557	# else
1558	# include <time.h>
1559	# endif
1560	#endif
1561	#ifdef HAVE_SYS_STAT_H
1562	#include <sys/stat.h>
1563	#endif
1564	],
1565	[
1566	struct time_t t;
1567	struct stat s = {0};
1568	t = s.st_birthtime;
1569	],
1570	samba_cv_stat_st_birthtime=yes, samba_cv_stat_st_birthtime=no)
1571	])
1572
1573	if test x"$samba_cv_stat_st_birthtime" = x"yes" ; then
1574	AC_DEFINE(HAVE_STAT_ST_BIRTHTIME, 1, [whether struct stat contains st_birthtime])
1575	fi
1576
1577	#####################################
1578	# needed for SRV lookups
1579	AC_CHECK_LIB(resolv, dn_expand)
1580	AC_CHECK_LIB(resolv, _dn_expand)
1581	AC_CHECK_LIB(resolv, __dn_expand)
1582
1583	#
1584	# Check for the functions putprpwnam, set_auth_parameters,
1585	# getspnam, bigcrypt and getprpwnam in -lsec and -lsecurity
1586	# Needed for OSF1 and HPUX.
1587	#
1588
1589	AC_LIBTESTFUNC(security, putprpwnam)
1590	AC_LIBTESTFUNC(sec, putprpwnam)
1591
1592	AC_LIBTESTFUNC(security, set_auth_parameters)
1593	AC_LIBTESTFUNC(sec, set_auth_parameters)
1594
1595	# UnixWare 7.x has its getspnam in -lgen
1596	AC_LIBTESTFUNC(gen, getspnam)
1597
1598	AC_LIBTESTFUNC(security, getspnam)
1599	AC_LIBTESTFUNC(sec, getspnam)
1600
1601	AC_LIBTESTFUNC(security, bigcrypt)
1602	AC_LIBTESTFUNC(sec, bigcrypt)
1603
1604	AC_LIBTESTFUNC(security, getprpwnam)
1605	AC_LIBTESTFUNC(sec, getprpwnam)
1606
1607	AC_CHECK_FUNCS(strsignal)
1608
1609	############################################
1610	# Check if we have libattr
1611	case "$host_os" in
1612	osf)
1613	AC_SEARCH_LIBS(getproplist, [proplist])
1614	AC_CHECK_FUNCS(getproplist fgetproplist setproplist fsetproplist)
1615	AC_CHECK_FUNCS(delproplist fdelproplist add_proplist_entry get_proplist_entry)
1616	AC_CHECK_FUNCS(sizeof_proplist_entry)
1617	;;
1618	*)
1619	AC_SEARCH_LIBS(getxattr, [attr])
1620	AC_CHECK_FUNCS(getxattr lgetxattr fgetxattr listxattr llistxattr)
1621	AC_CHECK_FUNCS(getea fgetea lgetea listea flistea llistea)
1622	AC_CHECK_FUNCS(removeea fremoveea lremoveea setea fsetea lsetea)
1623	AC_CHECK_FUNCS(flistxattr removexattr lremovexattr fremovexattr)
1624	AC_CHECK_FUNCS(setxattr lsetxattr fsetxattr)
1625	AC_CHECK_FUNCS(attr_get attr_list attr_set attr_remove)
1626	AC_CHECK_FUNCS(attr_getf attr_listf attr_setf attr_removef)
1627	;;
1628	esac
1629
1630	########################################################
1631	# Check if attropen() is present if this is Solaris
1632	case "$host_os" in
1633	solaris)
1634	AC_CHECK_FUNCS(attropen)
1635	;;
1636	esac
1637
1638	########################################################
1639	# Do xattr functions take additional options like on Darwin?
1640	if test x"$ac_cv_func_getxattr" = x"yes" ; then
1641	AC_CACHE_CHECK([whether xattr interface takes additional options], smb_attr_cv_xattr_add_opt, [
1642	old_LIBS=$LIBS
1643	LIBS="$LIBS $ACL_LIBS"
1644	AC_TRY_COMPILE([
1645	#include <sys/types.h>
1646	#if HAVE_ATTR_XATTR_H
1647	#include <attr/xattr.h>
1648	#elif HAVE_SYS_XATTR_H
1649	#include <sys/xattr.h>
1650	#endif
1651	],[
1652	getxattr(0, 0, 0, 0, 0, 0);
1653	],
1654	[smb_attr_cv_xattr_add_opt=yes],
1655	[smb_attr_cv_xattr_add_opt=no;LIBS=$old_LIBS])
1656	])
1657	if test x"$smb_attr_cv_xattr_add_opt" = x"yes"; then
1658	AC_DEFINE(XATTR_ADD_OPT, 1, [xattr functions have additional options])
1659	fi
1660	fi
1661
1662	# Check if we have extattr
1663	case "$host_os" in
1664	freebsd4 \| dragonfly )
1665	AC_DEFINE(BROKEN_EXTATTR, 1, [Does extattr API work])
1666	;;
1667	*)
1668	AC_CHECK_FUNCS(extattr_delete_fd extattr_delete_file extattr_delete_link)
1669	AC_CHECK_FUNCS(extattr_get_fd extattr_get_file extattr_get_link)
1670	AC_CHECK_FUNCS(extattr_list_fd extattr_list_file extattr_list_link)
1671	AC_CHECK_FUNCS(extattr_set_fd extattr_set_file extattr_set_link)
1672	;;
1673	esac
1674
1675	AC_DISABLE_STATIC
1676	AC_ENABLE_SHARED
1677
1678	# Set defaults
1679	PIE_CFLAGS=""
1680	PIE_LDFLAGS=""
1681	AC_ARG_ENABLE(pie, [AS_HELP_STRING([--enable-pie], [Turn on pie support if available (default=yes)])])
1682
1683	if test "x$enable_pie" != xno
1684	then
1685	AC_CACHE_CHECK(for -pie and -fPIE, samba_cv_fpie,
1686	[
1687	cat > conftest.c <<EOF
1688	int foo;
1689	main () { return 0;}
1690	EOF
1691	if AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS -pie -fPIE -o conftest conftest.c 1>&AS_MESSAGE_LOG_FD])
1692	then
1693	samba_cv_fpie=yes
1694	else
1695	samba_cv_fpie=no
1696	fi
1697	rm -f conftest*
1698	])
1699	if test x"${samba_cv_fpie}" = x"yes"
1700	then
1701	PIE_CFLAGS="-fPIE"
1702	PIE_LDFLAGS="-pie"
1703	fi
1704	fi
1705
1706	# Set defaults
1707	RELRO_LDFLAGS=""
1708	AC_ARG_ENABLE(relro, [AS_HELP_STRING([--enable-relro], [Turn on Relocations Read-Only (relro) support if available (default=yes)])])
1709
1710	if test "x$enable_relro" != xno
1711	then
1712	AC_CACHE_CHECK([for -Wl,-z,relro], samba_cv_relro,
1713	[
1714	cat > conftest.c <<EOF
1715	int foo;
1716	main () { return 0;}
1717	EOF
1718	if AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS -Wl,-z,relro -o conftest conftest.c 1>&AS_MESSAGE_LOG_FD])
1719	then
1720	samba_cv_relro=yes
1721	else
1722	samba_cv_relro=no
1723	fi
1724	rm -f conftest*
1725	])
1726	if test x"${samba_cv_relro}" = x"yes"
1727	then
1728	RELRO_LDFLAGS="-Wl,-z,relro"
1729	fi
1730	fi
1731
1732	# Set defaults
1733	SYMSEXT="syms"
1734	AC_SUBST(SYMSEXT)
1735
1736	# Assume non-shared by default and override below
1737	BLDSHARED="false"
1738
1739	# these are the defaults, good for lots of systems
1740	HOST_OS="$host_os"
1741	LDSHFLAGS="-shared"
1742	MODULE_EXPORTS=""
1743	SONAMEFLAG="#"
1744	SHLD="\${CC} \${CFLAGS}"
1745	PICFLAG="${PIE_CFLAGS}"
1746	SHLIBEXT="so"
1747	DSO_EXPORTS=""
1748
1749	# this bit needs to be modified for each OS that supports share libs
1750	# You need to specify how to create a shared library and
1751	# how to compile C code to produce PIC object files
1752
1753	AC_MSG_CHECKING([ability to build shared libraries])
1754
1755	# and these are for particular systems
1756	case "$host_os" in
1757	linux) AC_DEFINE(LINUX,1,[Whether the host os is linux])
1758	BLDSHARED="true"
1759	if test "${ac_cv_gnu_ld_no_default_allow_shlib_undefined}" = "yes"; then
1760	LDSHFLAGS="-shared -Wl,-Bsymbolic -Wl,--allow-shlib-undefined"
1761	else
1762	LDSHFLAGS="-shared -Wl,-Bsymbolic"
1763	fi
1764	DYNEXP="-Wl,--export-dynamic"
1765	PICFLAG="-fPIC"
1766	SONAMEFLAG="-Wl,-soname="
1767	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1768	;;
1769	solaris) AC_DEFINE(SUNOS5,1,[Whether the host os is solaris])
1770	BLDSHARED="true"
1771	LDSHFLAGS="-G"
1772	SONAMEFLAG="-h "
1773	if test "${GCC}" = "yes"; then
1774	PICFLAG="-fPIC"
1775	SONAMEFLAG="-Wl,-soname="
1776	if test "${ac_cv_prog_gnu_ld}" = "yes"; then
1777	DYNEXP="-Wl,-E"
1778	fi
1779	else
1780	PICFLAG="-KPIC"
1781	## ${CFLAGS} added for building 64-bit shared
1782	## libs using Sun's Compiler
1783	LDSHFLAGS="-G \${CFLAGS}"
1784	fi
1785	AC_DEFINE(STAT_ST_BLOCKSIZE,512,[The size of a block])
1786	AC_DEFINE(BROKEN_GETGRNAM,1,[Does getgrnam work correctly])
1787	;;
1788	sunos) AC_DEFINE(SUNOS4,1,[Whether the host os is sunos4])
1789	BLDSHARED="true"
1790	LDSHFLAGS="-G"
1791	SONAMEFLAG="-Wl,-h,"
1792	PICFLAG="-KPIC" # Is this correct for SunOS
1793	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1794	AC_DEFINE(BROKEN_GETGRNAM,1,[Does getgrnam work correctly])
1795	;;
1796	netbsd \| freebsd \| dragonfly )
1797	BLDSHARED="true"
1798	LDSHFLAGS="-shared"
1799	DYNEXP="-Wl,--export-dynamic"
1800	SONAMEFLAG="-Wl,-soname,"
1801	PICFLAG="-fPIC -DPIC"
1802	AC_DEFINE(STAT_ST_BLOCKSIZE,512,[The size of a block])
1803	AC_DEFINE(BROKEN_GETGRNAM,1,[Does getgrnam work correctly])
1804	;;
1805	openbsd) BLDSHARED="true"
1806	LDSHFLAGS="-shared"
1807	DYNEXP="-Wl,-Bdynamic"
1808	SONAMEFLAG="-Wl,-soname,"
1809	PICFLAG="-fPIC"
1810	AC_DEFINE(STAT_ST_BLOCKSIZE,512,[The size of a block])
1811	AC_DEFINE(BROKEN_GETGRNAM,1,[Does getgrnam work correctly])
1812	;;
1813	irix) AC_DEFINE(IRIX,1,[Whether the host os is irix])
1814	case "$host_os" in
1815	irix6) AC_DEFINE(IRIX6,1,[Whether the host os is irix6])
1816	;;
1817	esac
1818	BLDSHARED="true"
1819	LDSHFLAGS="-set_version sgi1.0 -shared"
1820	SONAMEFLAG="-soname "
1821	SHLD="\${LD}"
1822	if test "${GCC}" = "yes"; then
1823	PICFLAG="-fPIC"
1824	else
1825	PICFLAG="-KPIC"
1826	fi
1827	AC_DEFINE(STAT_ST_BLOCKSIZE,512,[The size of a block])
1828	;;
1829	aix) AC_DEFINE(AIX,1,[Whether the host os is aix])
1830	BLDSHARED="true"
1831	# use expfull to export underscored symbols
1832	# add rtl to remove /lib/crt0.o warning
1833	LDSHFLAGS="-Wl,-G,-bexpfull,-bbigtoc,-brtl"
1834	DYNEXP="-Wl,-brtl,-bexpfull,-bbigtoc"
1835	PICFLAG="-O2"
1836	# as AIX code is always position independent...
1837	# .po will just create compile warnings, use po.o:
1838	if test "${GCC}" != "yes"; then
1839	## for funky AIX compiler using strncpy()
1840	CFLAGS="$CFLAGS -D_LINUX_SOURCE_COMPAT -qmaxmem=32000"
1841	fi
1842
1843	AC_DEFINE(STAT_ST_BLOCKSIZE,DEV_BSIZE,[The size of a block])
1844	AC_DEFINE(BROKEN_STRNLEN,1,[Does strnlen work correctly])
1845	AC_DEFINE(BROKEN_STRNDUP,1,[Does strndup work correctly])
1846	;;
1847	hpux) AC_DEFINE(HPUX,1,[Whether the host os is HPUX])
1848	# Use special PIC flags for the native HP-UX compiler.
1849	BLDSHARED="true"
1850	SHLD="cc"
1851	LDSHFLAGS="-b -Wl,-B,symbolic,-b,-z"
1852	SONAMEFLAG="-Wl,+h "
1853	PICFLAG="+z"
1854	if test "${GCC}" = "yes"; then
1855	PICFLAG="-fPIC"
1856	else
1857	PICFLAG="+z +ESnolit"
1858	fi
1859	if test "$host_cpu" = "ia64"; then
1860	SHLIBEXT="so"
1861	PICFLAG="+z"
1862	DYNEXP="-Wl,-E,+b/usr/local/lib/hpux32:/usr/lib/hpux32"
1863	else
1864	SHLIBEXT="sl"
1865	DYNEXP="-Wl,-E,+b/usr/local/lib:/usr/lib"
1866	fi
1867	AC_DEFINE(STAT_ST_BLOCKSIZE,8192,[The size of a block])
1868	AC_DEFINE(POSIX_ACL_NEEDS_MASK,1,[Does a POSIX ACL need a mask element])
1869	;;
1870	qnx) AC_DEFINE(QNX,1,[Whether the host os is qnx])
1871	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1872	;;
1873	osf) AC_DEFINE(OSF1,1,[Whether the host os is osf1])
1874	BLDSHARED="true"
1875	LDSHFLAGS="-shared"
1876	SONAMEFLAG="-Wl,-soname,"
1877	PICFLAG="-fPIC"
1878	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1879	AC_DEFINE(BROKEN_GETGRNAM,1,[Does getgrnam work correctly])
1880	;;
1881	sco) AC_DEFINE(SCO,1,[Whether the host os is sco unix])
1882	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1883	;;
1884	unixware) AC_DEFINE(UNIXWARE,1,[Whether the host os is unixware])
1885	BLDSHARED="true"
1886	LDSHFLAGS="-shared"
1887	SONAMEFLAG="-Wl,-soname,"
1888	PICFLAG="-KPIC"
1889	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1890	;;
1891	next2) AC_DEFINE(NEXT2,1,[Whether the host os is NeXT v2])
1892	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1893	;;
1894	dgux) AC_CHECK_PROG( ROFF, groff, [groff -etpsR -Tascii -man])
1895	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1896	;;
1897	sysv4) AC_DEFINE(SYSV,1,[Whether this is a system V system])
1898	case "$host" in
1899	-univel-) if [ test "$GCC" != yes ]; then
1900	AC_DEFINE(HAVE_MEMSET,1,[Whether memset() is available])
1901	fi
1902	LDSHFLAGS="-G"
1903	DYNEXP="-Bexport"
1904	;;
1905	mips-sni-sysv4) AC_DEFINE(RELIANTUNIX,1,[Whether the host os is reliantunix]);;
1906	esac
1907	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1908	;;
1909
1910	sysv5) AC_DEFINE(SYSV,1,[Whether this is a system V system])
1911	if [ test "$GCC" != yes ]; then
1912	AC_DEFINE(HAVE_MEMSET,1,[Whether memset() is available])
1913	fi
1914	LDSHFLAGS="-G"
1915	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1916	;;
1917	vos) AC_DEFINE(STAT_ST_BLOCKSIZE,4096)
1918	BLDSHARED="false"
1919	LDSHFLAGS=""
1920	;;
1921
1922	darwin) AC_DEFINE(DARWINOS,1,[Whether the host os is Darwin/MacOSX])
1923	BLDSHARED="true"
1924	LDSHFLAGS="-dynamiclib -flat_namespace -undefined suppress"
1925	CFLAGS="$CFLAGS -fno-common"
1926	SHLD="\${CC}"
1927	SHLIBEXT="dylib"
1928	MODULE_EXPORTS="-exported_symbols_list \$(srcdir)/exports/modules-darwin.syms"
1929	SHLIBEXT="dylib"
1930	# Since gcc doesn't fail on unrecognised options, the
1931	# PIE test incorrectly succeeds. Darwin gcc does not
1932	# actually support the PIE stuff.
1933	PIE_LDFLAGS=
1934	PIE_CFLAGS=
1935	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1936	;;
1937
1938	*)
1939	AC_DEFINE(STAT_ST_BLOCKSIZE,512)
1940	;;
1941	esac
1942
1943	if test "$enable_shared" != "yes"; then
1944	BLDSHARED=false
1945	fi
1946
1947	if test "$enable_shared" = yes -a "${ac_cv_gnu_ld_version_script}" = yes; then
1948	DSO_EXPORTS=\$$DSO_EXPORTS_CMD$
1949	fi
1950
1951	if test x"$BLDSHARED" = x"true" ; then
1952	LDFLAGS="$LDFLAGS -L./bin"
1953	fi
1954
1955	AC_MSG_RESULT($BLDSHARED)
1956
1957	AC_MSG_CHECKING([LDFLAGS])
1958	AC_MSG_RESULT([$LDFLAGS])
1959	AC_MSG_CHECKING([DYNEXP])
1960	AC_MSG_RESULT([$DYNEXP])
1961
1962	#######################################################
1963	# test whether building a shared library actually works
1964	if test $BLDSHARED = true; then
1965
1966	AC_MSG_CHECKING([SHLD])
1967	AC_MSG_RESULT([$SHLD])
1968	AC_MSG_CHECKING([LDSHFLAGS])
1969	AC_MSG_RESULT([$LDSHFLAGS])
1970
1971	AC_MSG_CHECKING([SHLIBEXT])
1972	AC_MSG_RESULT([$SHLIBEXT])
1973	AC_MSG_CHECKING([SONAMEFLAG])
1974	AC_MSG_RESULT([$SONAMEFLAG])
1975
1976	AC_MSG_CHECKING([PICFLAG])
1977	AC_MSG_RESULT([$PICFLAG])
1978
1979	AC_MSG_CHECKING([NSSSONAMEVERSIONSUFFIX])
1980	AC_MSG_RESULT([$NSSSONAMEVERSIONSUFFIX])
1981
1982	AC_CACHE_CHECK([whether building shared libraries actually works],
1983	[ac_cv_shlib_works],[
1984	# try building a trivial shared library
1985	ac_cv_shlib_works=no
1986	# The $SHLD and $LDSHFLAGS variables may contain references to other
1987	# variables so they need to be eval'ed.
1988	$CC $CPPFLAGS $CFLAGS $PICFLAG -c -o \
1989	shlib.o ${srcdir-.}/tests/shlib.c && \
1990	`eval echo $SHLD` `eval echo $LDSHFLAGS` -o "shlib.$SHLIBEXT" \
1991	shlib.o && ac_cv_shlib_works=yes
1992	rm -f "shlib.$SHLIBEXT" shlib.o
1993
1994	])
1995	if test $ac_cv_shlib_works = no; then
1996	BLDSHARED=false
1997	fi
1998	fi
1999
2000	if test x"$BLDSHARED" != x"true"; then
2001	LDSHFLAGS="shared-libraries-disabled"
2002	SONAMEFLAG="shared-libraries-disabled"
2003	NSSSONAMEVERSIONSUFFIX="shared-libraries-disabled"
2004	SHLD="shared-libraries-disabled"
2005	PICFLAG="${PIE_CFLAGS}"
2006	SHLIBEXT="shared_libraries_disabled"
2007	fi
2008
2009	AC_MSG_CHECKING([used PICFLAG])
2010	AC_MSG_RESULT([$PICFLAG])
2011
2012	AC_DEFINE_UNQUOTED(SHLIBEXT, "$SHLIBEXT", [Shared library extension])
2013
2014	AC_LIBREPLACE_RUNTIME_LIB_PATH_VAR
2015
2016	################
2017
2018	AC_CACHE_CHECK([for long long],samba_cv_have_longlong,[
2019	AC_TRY_RUN([#include <stdio.h>
2020	main() { long long x = 1000000; x *= x; exit(((x/1000000) == 1000000)? 0: 1); }],
2021	samba_cv_have_longlong=yes,samba_cv_have_longlong=no,samba_cv_have_longlong=cross)])
2022	if test x"$samba_cv_have_longlong" = x"yes"; then
2023	AC_DEFINE(HAVE_LONGLONG,1,[Whether the host supports long long's])
2024	AC_CHECK_TYPE(intptr_t, unsigned long long)
2025	else
2026	AC_CHECK_TYPE(intptr_t, unsigned long)
2027	fi
2028
2029	#
2030	# Check if the compiler supports the LL prefix on long long integers.
2031	# AIX needs this.
2032
2033	AC_CACHE_CHECK([for LL suffix on long long integers],samba_cv_compiler_supports_ll, [
2034	AC_TRY_COMPILE([#include <stdio.h>],[long long i = 0x8000000000LL],
2035	samba_cv_compiler_supports_ll=yes,samba_cv_compiler_supports_ll=no)])
2036	if test x"$samba_cv_compiler_supports_ll" = x"yes"; then
2037	AC_DEFINE(COMPILER_SUPPORTS_LL,1,[Whether the compiler supports the LL prefix on long long integers])
2038	fi
2039
2040
2041	AC_CACHE_CHECK([for 64 bit time_t],samba_cv_SIZEOF_TIME_T,[
2042	AC_TRY_RUN([#include <time.h>
2043	main() { exit((sizeof(time_t) == 8) ? 0 : 1); }],
2044	samba_cv_SIZEOF_TIME_T=yes,samba_cv_SIZEOF_TIME_T=no,samba_cv_SIZEOF_TIME_T=cross)])
2045	if test x"$samba_cv_SIZEOF_TIME_T" = x"yes"; then
2046	AC_DEFINE(SIZEOF_TIME_T,8,[The size of the 'time_t' type])
2047	fi
2048
2049	AC_CACHE_CHECK([for 64 bit off_t],samba_cv_SIZEOF_OFF_T,[
2050	AC_TRY_RUN([#include <stdio.h>
2051	#include <sys/stat.h>
2052	main() { exit((sizeof(off_t) == 8) ? 0 : 1); }],
2053	samba_cv_SIZEOF_OFF_T=yes,samba_cv_SIZEOF_OFF_T=no,samba_cv_SIZEOF_OFF_T=cross)])
2054	if test x"$samba_cv_SIZEOF_OFF_T" = x"yes"; then
2055	AC_DEFINE(SIZEOF_OFF_T,8,[The size of the 'off_t' type])
2056	fi
2057
2058	AC_CACHE_CHECK([for off64_t],samba_cv_HAVE_OFF64_T,[
2059	AC_TRY_RUN([
2060	#if defined(HAVE_UNISTD_H)
2061	#include <unistd.h>
2062	#endif
2063	#include <stdio.h>
2064	#include <sys/stat.h>
2065	main() { struct stat64 st; off64_t s; if (sizeof(off_t) == sizeof(off64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
2066	samba_cv_HAVE_OFF64_T=yes,samba_cv_HAVE_OFF64_T=no,samba_cv_HAVE_OFF64_T=cross)])
2067	if test x"$samba_cv_HAVE_OFF64_T" = x"yes"; then
2068	AC_DEFINE(HAVE_OFF64_T,1,[Whether off64_t is available])
2069	fi
2070
2071	AC_CACHE_CHECK([for 64 bit ino_t],samba_cv_SIZEOF_INO_T,[
2072	AC_TRY_RUN([
2073	#if defined(HAVE_UNISTD_H)
2074	#include <unistd.h>
2075	#endif
2076	#include <stdio.h>
2077	#include <sys/stat.h>
2078	main() { exit((sizeof(ino_t) == 8) ? 0 : 1); }],
2079	samba_cv_SIZEOF_INO_T=yes,samba_cv_SIZEOF_INO_T=no,samba_cv_SIZEOF_INO_T=cross)])
2080	if test x"$samba_cv_SIZEOF_INO_T" = x"yes"; then
2081	AC_DEFINE(SIZEOF_INO_T,8,[The size of the 'ino_t' type])
2082	fi
2083
2084	AC_CACHE_CHECK([for ino64_t],samba_cv_HAVE_INO64_T,[
2085	AC_TRY_RUN([
2086	#if defined(HAVE_UNISTD_H)
2087	#include <unistd.h>
2088	#endif
2089	#include <stdio.h>
2090	#include <sys/stat.h>
2091	main() { struct stat64 st; ino64_t s; if (sizeof(ino_t) == sizeof(ino64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
2092	samba_cv_HAVE_INO64_T=yes,samba_cv_HAVE_INO64_T=no,samba_cv_HAVE_INO64_T=cross)])
2093	if test x"$samba_cv_HAVE_INO64_T" = x"yes"; then
2094	AC_DEFINE(HAVE_INO64_T,1,[Whether the 'ino64_t' type is available])
2095	fi
2096
2097	AC_CACHE_CHECK([for 64 bit dev_t],samba_cv_SIZEOF_DEV_T,[
2098	AC_TRY_RUN([
2099	#if defined(HAVE_UNISTD_H)
2100	#include <unistd.h>
2101	#endif
2102	#include <stdio.h>
2103	#include <sys/stat.h>
2104	main() { exit((sizeof(dev_t) == 8) ? 0 : 1); }],
2105	samba_cv_SIZEOF_DEV_T=yes,samba_cv_SIZEOF_DEV_T=no,samba_cv_SIZEOF_DEV_T=cross)])
2106	if test x"$samba_cv_SIZEOF_DEV_T" = x"yes"; then
2107	AC_DEFINE(SIZEOF_DEV_T,8,[The size of the 'dev_t' type])
2108	fi
2109
2110	AC_CACHE_CHECK([for dev64_t],samba_cv_HAVE_DEV64_T,[
2111	AC_TRY_RUN([
2112	#if defined(HAVE_UNISTD_H)
2113	#include <unistd.h>
2114	#endif
2115	#include <stdio.h>
2116	#include <sys/stat.h>
2117	main() { struct stat64 st; dev64_t s; if (sizeof(dev_t) == sizeof(dev64_t)) exit(1); exit((lstat64("/dev/null", &st)==0)?0:1); }],
2118	samba_cv_HAVE_DEV64_T=yes,samba_cv_HAVE_DEV64_T=no,samba_cv_HAVE_DEV64_T=cross)])
2119	if test x"$samba_cv_HAVE_DEV64_T" = x"yes"; then
2120	AC_DEFINE(HAVE_DEV64_T,1,[Whether the 'dev64_t' type is available])
2121	fi
2122
2123	AC_CACHE_CHECK([for struct dirent64],samba_cv_HAVE_STRUCT_DIR64,[
2124	AC_TRY_COMPILE([
2125	#if defined(HAVE_UNISTD_H)
2126	#include <unistd.h>
2127	#endif
2128	#include <sys/types.h>
2129	#include <dirent.h>],
2130	[DIR64 de;],
2131	samba_cv_HAVE_STRUCT_DIR64=yes,samba_cv_HAVE_STRUCT_DIR64=no)])
2132	if test x"$samba_cv_HAVE_STRUCT_DIR64" = x"yes" && test x"$ac_cv_func_readdir64" = x"yes"; then
2133	AC_DEFINE(HAVE_STRUCT_DIR64,1,[Whether the 'DIR64' abstract data type is available])
2134	fi
2135
2136	AC_CACHE_CHECK([for struct dirent64],samba_cv_HAVE_STRUCT_DIRENT64,[
2137	AC_TRY_COMPILE([
2138	#if defined(HAVE_UNISTD_H)
2139	#include <unistd.h>
2140	#endif
2141	#include <sys/types.h>
2142	#include <dirent.h>],
2143	[struct dirent64 de;],
2144	samba_cv_HAVE_STRUCT_DIRENT64=yes,samba_cv_HAVE_STRUCT_DIRENT64=no)])
2145	if test x"$samba_cv_HAVE_STRUCT_DIRENT64" = x"yes" && test x"$ac_cv_func_readdir64" = x"yes"; then
2146	AC_DEFINE(HAVE_STRUCT_DIRENT64,1,[Whether the 'dirent64' struct is available])
2147	fi
2148
2149	AC_CACHE_CHECK([for major macro],samba_cv_HAVE_DEVICE_MAJOR_FN,[
2150	AC_TRY_RUN([
2151	#if defined(HAVE_UNISTD_H)
2152	#include <unistd.h>
2153	#endif
2154	#include <sys/types.h>
2155	main() { dev_t dev; int i = major(dev); return 0; }],
2156	samba_cv_HAVE_DEVICE_MAJOR_FN=yes,samba_cv_HAVE_DEVICE_MAJOR_FN=no,samba_cv_HAVE_DEVICE_MAJOR_FN=cross)])
2157	if test x"$samba_cv_HAVE_DEVICE_MAJOR_FN" = x"yes"; then
2158	AC_DEFINE(HAVE_DEVICE_MAJOR_FN,1,[Whether the major macro for dev_t is available])
2159	fi
2160
2161	AC_CACHE_CHECK([for minor macro],samba_cv_HAVE_DEVICE_MINOR_FN,[
2162	AC_TRY_RUN([
2163	#if defined(HAVE_UNISTD_H)
2164	#include <unistd.h>
2165	#endif
2166	#include <sys/types.h>
2167	main() { dev_t dev; int i = minor(dev); return 0; }],
2168	samba_cv_HAVE_DEVICE_MINOR_FN=yes,samba_cv_HAVE_DEVICE_MINOR_FN=no,samba_cv_HAVE_DEVICE_MINOR_FN=cross)])
2169	if test x"$samba_cv_HAVE_DEVICE_MINOR_FN" = x"yes"; then
2170	AC_DEFINE(HAVE_DEVICE_MINOR_FN,1,[Whether the minor macro for dev_t is available])
2171	fi
2172
2173	AC_CACHE_CHECK([for makedev macro],samba_cv_HAVE_MAKEDEV,[
2174	AC_TRY_RUN([
2175	#if defined(HAVE_UNISTD_H)
2176	#include <unistd.h>
2177	#endif
2178	#include <sys/types.h>
2179	main() { dev_t dev = makedev(1,2); return 0; }],
2180	samba_cv_HAVE_MAKEDEV=yes,samba_cv_HAVE_MAKEDEV=no,samba_cv_HAVE_MAKEDEV=cross)])
2181	if test x"$samba_cv_HAVE_MAKEDEV" = x"yes"; then
2182	AC_DEFINE(HAVE_MAKEDEV,1,[Whether the macro for makedev is available])
2183	fi
2184
2185	AC_CACHE_CHECK([for unsigned char],samba_cv_HAVE_UNSIGNED_CHAR,[
2186	AC_TRY_RUN([#include <stdio.h>
2187	main() { char c; c=250; exit((c > 0)?0:1); }],
2188	samba_cv_HAVE_UNSIGNED_CHAR=yes,samba_cv_HAVE_UNSIGNED_CHAR=no,samba_cv_HAVE_UNSIGNED_CHAR=cross)])
2189	if test x"$samba_cv_HAVE_UNSIGNED_CHAR" = x"yes"; then
2190	AC_DEFINE(HAVE_UNSIGNED_CHAR,1,[Whether the 'unsigned char' type is available])
2191	fi
2192
2193	AC_CACHE_CHECK([whether seekdir returns void],samba_cv_SEEKDIR_RETURNS_VOID,[
2194	AC_TRY_COMPILE([#include <sys/types.h>
2195	#include <dirent.h>
2196	void seekdir(DIR *d, long loc) { return; }],[return 0;],
2197	samba_cv_SEEKDIR_RETURNS_VOID=yes,samba_cv_SEEKDIR_RETURNS_VOID=no)])
2198	if test x"$samba_cv_SEEKDIR_RETURNS_VOID" = x"yes"; then
2199	AC_DEFINE(SEEKDIR_RETURNS_VOID,1,[Whether seekdir returns void])
2200	fi
2201
2202	AC_CACHE_CHECK([for __FUNCTION__ macro],samba_cv_HAVE_FUNCTION_MACRO,[
2203	AC_TRY_COMPILE([#include <stdio.h>], [printf("%s\n", __FUNCTION__);],
2204	samba_cv_HAVE_FUNCTION_MACRO=yes,samba_cv_HAVE_FUNCTION_MACRO=no)])
2205	if test x"$samba_cv_HAVE_FUNCTION_MACRO" = x"yes"; then
2206	AC_DEFINE(HAVE_FUNCTION_MACRO,1,[Whether there is a __FUNCTION__ macro])
2207	fi
2208
2209	AC_CACHE_CHECK([if gettimeofday takes tz argument],samba_cv_HAVE_GETTIMEOFDAY_TZ,[
2210	AC_TRY_LINK([
2211	#include <sys/time.h>
2212	#include <unistd.h>], [struct timeval tv; return gettimeofday(&tv, NULL);],
2213	samba_cv_HAVE_GETTIMEOFDAY_TZ=yes,
2214	samba_cv_HAVE_GETTIMEOFDAY_TZ=no)])
2215	if test x"$samba_cv_HAVE_GETTIMEOFDAY_TZ" = x"yes"; then
2216	AC_DEFINE(HAVE_GETTIMEOFDAY_TZ,1,[Whether gettimeofday takes a tz argument])
2217	fi
2218
2219	if test x"$samba_cv_WITH_PROFILE" = x"yes"; then
2220
2221	# On some systems (eg. Linux) librt can pull in libpthread. We
2222	# don't want this to happen because libpthreads changes signal delivery
2223	# semantics in ways we are not prepared for. This breaks Linux oplocks
2224	# which rely on signals.
2225
2226	AC_LIBTESTFUNC(rt, clock_gettime,
2227	[
2228	AC_DEFINE(HAVE_CLOCK_GETTIME, 1,
2229	[Whether clock_gettime is available])
2230	SMB_CHECK_CLOCK_ID(CLOCK_MONOTONIC)
2231	SMB_CHECK_CLOCK_ID(CLOCK_PROCESS_CPUTIME_ID)
2232	SMB_CHECK_CLOCK_ID(CLOCK_REALTIME)
2233	])
2234
2235	fi
2236
2237	AC_CACHE_CHECK([for broken readdir name],samba_cv_HAVE_BROKEN_READDIR_NAME,[
2238	AC_TRY_RUN([#include <sys/types.h>
2239	#include <dirent.h>
2240	main() { struct dirent di; DIR d = opendir("."); di = readdir(d);
2241	if (di && di->d_name[-2] == '.' && di->d_name[-1] == 0 &&
2242	di->d_name[0] == 0) exit(0); exit(1);} ],
2243	samba_cv_HAVE_BROKEN_READDIR_NAME=yes,samba_cv_HAVE_BROKEN_READDIR_NAME=no,samba_cv_HAVE_BROKEN_READDIR_NAME=cross)])
2244	if test x"$samba_cv_HAVE_BROKEN_READDIR_NAME" = x"yes"; then
2245	AC_DEFINE(HAVE_BROKEN_READDIR_NAME,1,[Whether readdir() returns the wrong name offset])
2246	fi
2247
2248	AC_CACHE_CHECK([for utimbuf],samba_cv_HAVE_UTIMBUF,[
2249	AC_TRY_COMPILE([#include <sys/types.h>
2250	#include <utime.h>],
2251	[struct utimbuf tbuf; tbuf.actime = 0; tbuf.modtime = 1; exit(utime("foo.c",&tbuf));],
2252	samba_cv_HAVE_UTIMBUF=yes,samba_cv_HAVE_UTIMBUF=no,samba_cv_HAVE_UTIMBUF=cross)])
2253	if test x"$samba_cv_HAVE_UTIMBUF" = x"yes"; then
2254	AC_DEFINE(HAVE_UTIMBUF,1,[Whether struct utimbuf is available])
2255	fi
2256
2257	##############
2258	# Check utmp details, but only if our OS offers utmp.h
2259	if test x"$ac_cv_header_utmp_h" = x"yes"; then
2260	dnl utmp and utmpx come in many flavours
2261	dnl We need to check for many of them
2262	dnl But we don't need to do each and every one, because our code uses
2263	dnl mostly just the utmp (not utmpx) fields.
2264
2265	AC_CHECK_FUNCS(pututline pututxline updwtmp updwtmpx getutmpx)
2266
2267	AC_CACHE_CHECK([for ut_name in utmp],samba_cv_HAVE_UT_UT_NAME,[
2268	AC_TRY_COMPILE([#include <sys/types.h>
2269	#include <utmp.h>],
2270	[struct utmp ut; ut.ut_name[0] = 'a';],
2271	samba_cv_HAVE_UT_UT_NAME=yes,samba_cv_HAVE_UT_UT_NAME=no,samba_cv_HAVE_UT_UT_NAME=cross)])
2272	if test x"$samba_cv_HAVE_UT_UT_NAME" = x"yes"; then
2273	AC_DEFINE(HAVE_UT_UT_NAME,1,[Whether the utmp struct has a property ut_name])
2274	fi
2275
2276	AC_CACHE_CHECK([for ut_user in utmp],samba_cv_HAVE_UT_UT_USER,[
2277	AC_TRY_COMPILE([#include <sys/types.h>
2278	#include <utmp.h>],
2279	[struct utmp ut; ut.ut_user[0] = 'a';],
2280	samba_cv_HAVE_UT_UT_USER=yes,samba_cv_HAVE_UT_UT_USER=no,samba_cv_HAVE_UT_UT_USER=cross)])
2281	if test x"$samba_cv_HAVE_UT_UT_USER" = x"yes"; then
2282	AC_DEFINE(HAVE_UT_UT_USER,1,[Whether the utmp struct has a property ut_user])
2283	fi
2284
2285	AC_CACHE_CHECK([for ut_id in utmp],samba_cv_HAVE_UT_UT_ID,[
2286	AC_TRY_COMPILE([#include <sys/types.h>
2287	#include <utmp.h>],
2288	[struct utmp ut; ut.ut_id[0] = 'a';],
2289	samba_cv_HAVE_UT_UT_ID=yes,samba_cv_HAVE_UT_UT_ID=no,samba_cv_HAVE_UT_UT_ID=cross)])
2290	if test x"$samba_cv_HAVE_UT_UT_ID" = x"yes"; then
2291	AC_DEFINE(HAVE_UT_UT_ID,1,[Whether the utmp struct has a property ut_id])
2292	fi
2293
2294	AC_CACHE_CHECK([for ut_host in utmp],samba_cv_HAVE_UT_UT_HOST,[
2295	AC_TRY_COMPILE([#include <sys/types.h>
2296	#include <utmp.h>],
2297	[struct utmp ut; ut.ut_host[0] = 'a';],
2298	samba_cv_HAVE_UT_UT_HOST=yes,samba_cv_HAVE_UT_UT_HOST=no,samba_cv_HAVE_UT_UT_HOST=cross)])
2299	if test x"$samba_cv_HAVE_UT_UT_HOST" = x"yes"; then
2300	AC_DEFINE(HAVE_UT_UT_HOST,1,[Whether the utmp struct has a property ut_host])
2301	fi
2302
2303	AC_CACHE_CHECK([for ut_time in utmp],samba_cv_HAVE_UT_UT_TIME,[
2304	AC_TRY_COMPILE([#include <sys/types.h>
2305	#include <utmp.h>],
2306	[struct utmp ut; time_t t; ut.ut_time = t;],
2307	samba_cv_HAVE_UT_UT_TIME=yes,samba_cv_HAVE_UT_UT_TIME=no,samba_cv_HAVE_UT_UT_TIME=cross)])
2308	if test x"$samba_cv_HAVE_UT_UT_TIME" = x"yes"; then
2309	AC_DEFINE(HAVE_UT_UT_TIME,1,[Whether the utmp struct has a property ut_time])
2310	fi
2311
2312	AC_CACHE_CHECK([for ut_tv in utmp],samba_cv_HAVE_UT_UT_TV,[
2313	AC_TRY_COMPILE([#include <sys/types.h>
2314	#include <utmp.h>],
2315	[struct utmp ut; struct timeval tv; ut.ut_tv = tv;],
2316	samba_cv_HAVE_UT_UT_TV=yes,samba_cv_HAVE_UT_UT_TV=no,samba_cv_HAVE_UT_UT_TV=cross)])
2317	if test x"$samba_cv_HAVE_UT_UT_TV" = x"yes"; then
2318	AC_DEFINE(HAVE_UT_UT_TV,1,[Whether the utmp struct has a property ut_tv])
2319	fi
2320
2321	AC_CACHE_CHECK([for ut_type in utmp],samba_cv_HAVE_UT_UT_TYPE,[
2322	AC_TRY_COMPILE([#include <sys/types.h>
2323	#include <utmp.h>],
2324	[struct utmp ut; ut.ut_type = 0;],
2325	samba_cv_HAVE_UT_UT_TYPE=yes,samba_cv_HAVE_UT_UT_TYPE=no,samba_cv_HAVE_UT_UT_TYPE=cross)])
2326	if test x"$samba_cv_HAVE_UT_UT_TYPE" = x"yes"; then
2327	AC_DEFINE(HAVE_UT_UT_TYPE,1,[Whether the utmp struct has a property ut_type])
2328	fi
2329
2330	AC_CACHE_CHECK([for ut_pid in utmp],samba_cv_HAVE_UT_UT_PID,[
2331	AC_TRY_COMPILE([#include <sys/types.h>
2332	#include <utmp.h>],
2333	[struct utmp ut; ut.ut_pid = 0;],
2334	samba_cv_HAVE_UT_UT_PID=yes,samba_cv_HAVE_UT_UT_PID=no,samba_cv_HAVE_UT_UT_PID=cross)])
2335	if test x"$samba_cv_HAVE_UT_UT_PID" = x"yes"; then
2336	AC_DEFINE(HAVE_UT_UT_PID,1,[Whether the utmp struct has a property ut_pid])
2337	fi
2338
2339	AC_CACHE_CHECK([for ut_exit in utmp],samba_cv_HAVE_UT_UT_EXIT,[
2340	AC_TRY_COMPILE([#include <sys/types.h>
2341	#include <utmp.h>],
2342	[struct utmp ut; ut.ut_exit.e_exit = 0;],
2343	samba_cv_HAVE_UT_UT_EXIT=yes,samba_cv_HAVE_UT_UT_EXIT=no,samba_cv_HAVE_UT_UT_EXIT=cross)])
2344	if test x"$samba_cv_HAVE_UT_UT_EXIT" = x"yes"; then
2345	AC_DEFINE(HAVE_UT_UT_EXIT,1,[Whether the utmp struct has a property ut_exit])
2346	fi
2347
2348	dnl Look for the IPv6 varient by preference. Many systems have both.
2349	AC_CACHE_CHECK([for ut_addr_v6 in utmp],samba_cv_HAVE_UT_UT_ADDR_V6,[
2350	AC_TRY_COMPILE([#include <sys/types.h>
2351	#include <utmp.h>],
2352	[struct utmp ut; ut.ut_addr_v6[0] = 0;],
2353	samba_cv_HAVE_UT_UT_ADDR_V6=yes,samba_cv_HAVE_UT_UT_ADDR_V6=no,samba_cv_HAVE_UT_UT_ADDR_V6=cross)])
2354	if test x"$samba_cv_HAVE_UT_UT_ADDR_V6" = x"yes"; then
2355	AC_DEFINE(HAVE_UT_UT_ADDR_V6,1,[Whether the utmp struct has a property ut_addr_v6])
2356	fi
2357
2358	AC_CACHE_CHECK([for ut_addr in utmp],samba_cv_HAVE_UT_UT_ADDR,[
2359	AC_TRY_COMPILE([#include <sys/types.h>
2360	#include <utmp.h>],
2361	[struct utmp ut; ut.ut_addr = 0;],
2362	samba_cv_HAVE_UT_UT_ADDR=yes,samba_cv_HAVE_UT_UT_ADDR=no,samba_cv_HAVE_UT_UT_ADDR=cross)])
2363	if test x"$samba_cv_HAVE_UT_UT_ADDR" = x"yes"; then
2364	AC_DEFINE(HAVE_UT_UT_ADDR,1,[Whether the utmp struct has a property ut_addr])
2365	fi
2366
2367	if test x$ac_cv_func_pututline = xyes ; then
2368	AC_CACHE_CHECK([whether pututline returns pointer],samba_cv_PUTUTLINE_RETURNS_UTMP,[
2369	AC_TRY_COMPILE([#include <sys/types.h>
2370	#include <utmp.h>],
2371	[struct utmp utarg; struct utmp *utreturn; utreturn = pututline(&utarg);],
2372	samba_cv_PUTUTLINE_RETURNS_UTMP=yes,samba_cv_PUTUTLINE_RETURNS_UTMP=no)])
2373	if test x"$samba_cv_PUTUTLINE_RETURNS_UTMP" = x"yes"; then
2374	AC_DEFINE(PUTUTLINE_RETURNS_UTMP,1,[Whether pututline returns pointer])
2375	fi
2376	fi
2377
2378	AC_CACHE_CHECK([for ut_syslen in utmpx],samba_cv_HAVE_UX_UT_SYSLEN,[
2379	AC_TRY_COMPILE([#include <sys/types.h>
2380	#include <utmpx.h>],
2381	[struct utmpx ux; ux.ut_syslen = 0;],
2382	samba_cv_HAVE_UX_UT_SYSLEN=yes,samba_cv_HAVE_UX_UT_SYSLEN=no,samba_cv_HAVE_UX_UT_SYSLEN=cross)])
2383	if test x"$samba_cv_HAVE_UX_UT_SYSLEN" = x"yes"; then
2384	AC_DEFINE(HAVE_UX_UT_SYSLEN,1,[Whether the utmpx struct has a property ut_syslen])
2385	fi
2386
2387	fi
2388	# end utmp details
2389
2390
2391	ICONV_LOOK_DIRS="/usr /usr/local /sw /opt"
2392	AC_ARG_WITH(libiconv,
2393	[AS_HELP_STRING([--with-libiconv=BASEDIR], [Use libiconv in BASEDIR/lib and BASEDIR/include (default=auto)])],
2394	[
2395	if test "$withval" = "no" ; then
2396	AC_MSG_ERROR([argument to --with-libiconv must be a directory])
2397	else
2398	if test "$withval" != "yes" ; then
2399	ICONV_PATH_SPEC=yes
2400	ICONV_LOOK_DIRS="$withval"
2401	fi
2402	fi
2403	])
2404
2405	for i in $ICONV_LOOK_DIRS ; do
2406
2407	save_LIBS="$LIBS"
2408	save_LDFLAGS="$LDFLAGS"
2409	save_CPPFLAGS="$CPPFLAGS"
2410
2411	iconv_current_LIBS=""
2412	iconv_current_LDFLAGS=""
2413	iconv_current_CPPFLAGS=""
2414
2415	ICONV_FOUND="no"
2416	unset libext
2417
2418	# This is here to handle -withval stuff for --with-libiconv
2419	# Perhaps we should always add a -L
2420	CPPFLAGS="$save_CPPFLAGS -I$i/include"
2421
2422	# Check lib and lib32 library variants to cater for IRIX ABI-specific
2423	# installation paths. This gets a little tricky since we might have iconv
2424	# in both libiconv and in libc. In this case the jm_ICONV test will always
2425	# succeed when the header is found. To counter this, make sure the
2426	# library directory is there and check the ABI directory first (which
2427	# should be harmless on other systems.
2428	# For IA64 HPUX systems, the libs are located in lib/hpux32 instead of lib.
2429	for l in "lib32" "lib" "lib/hpux32"; do
2430	if test -d "$i/$l" ; then
2431	LDFLAGS="$save_LDFLAGS -L$i/$l"
2432	LIBS=
2433	export LDFLAGS LIBS CPPFLAGS
2434	# Try to find iconv(3)
2435	jm_ICONV($i/$l)
2436	if test x"$ICONV_FOUND" = "xyes" ; then
2437	libext="$l"
2438	break
2439	fi
2440	fi
2441	done
2442
2443	if test x"$ICONV_FOUND" = "xyes" ; then
2444	iconv_current_LDFLAGS="-L$i/$libext"
2445	iconv_current_CPPFLAGS="-I$i/include"
2446
2447	if test x"$jm_cv_lib_iconv" != x; then
2448	iconv_current_LIBS="$LIBS -l$jm_cv_lib_iconv"
2449	else
2450	# We found iconv in libc.
2451	iconv_current_LIBS=""
2452	fi
2453
2454	fi
2455
2456	if test x"$ICONV_FOUND" = "xyes" ; then
2457
2458	LDFLAGS="$save_LDFLAGS $iconv_current_LDFLAGS"
2459	CPPFLAGS="$save_CPPFLAGS $iconv_current_CPPFLAGS"
2460	LIBS="$save_LIBS $iconv_current_LIBS"
2461	export LDFLAGS LIBS CPPFLAGS
2462
2463	default_dos_charset=no
2464	default_display_charset=no
2465	default_unix_charset=no
2466
2467	# check for default dos charset name
2468	for j in CP850 IBM850 ; do
2469	rjs_CHARSET($j)
2470	default_dos_charset="$ICONV_CHARSET"
2471	if test x"$default_dos_charset" = x"$j"; then
2472	break
2473	fi
2474	done
2475
2476	# check for default display charset name
2477	for j in ASCII 646 ; do
2478	rjs_CHARSET($j)
2479	default_display_charset="$ICONV_CHARSET"
2480	if test x"$default_display_charset" = x"$j"; then
2481	break
2482	fi
2483	done
2484
2485	# check for default unix charset name
2486	for j in UTF-8 UTF8 ; do
2487	rjs_CHARSET($j)
2488	default_unix_charset="$ICONV_CHARSET"
2489	if test x"$default_unix_charset" = x"$j"; then
2490	break
2491	fi
2492	done
2493
2494	if test "$default_dos_charset" != "no" -a \
2495	"$default_dos_charset" != "cross" -a \
2496	"$default_display_charset" != "no" -a \
2497	"$default_display_charset" != "cross" -a \
2498	"$default_unix_charset" != "no" -a \
2499	"$default_unix_charset" != "cross"
2500	then
2501	samba_cv_HAVE_NATIVE_ICONV=yes
2502	else
2503	if test "$default_dos_charset" = "cross" -o \
2504	"$default_display_charset" = "cross" -o \
2505	"$default_unix_charset" = "cross"
2506	then
2507	samba_cv_HAVE_NATIVE_ICONV=cross
2508	else
2509	samba_cv_HAVE_NATIVE_ICONV=no
2510	fi
2511	fi
2512
2513	# At this point, we have a libiconv candidate. We know that
2514	# we have the right headers and libraries, but we don't know
2515	# whether it does the conversions we want. We can't test this
2516	# because we are cross-compiling. This is not necessarily a big
2517	# deal, since we can't guarantee that the results we get now will
2518	# match the results we get at runtime anyway.
2519	if test x"$samba_cv_HAVE_NATIVE_ICONV" = x"cross" ; then
2520	default_dos_charset="CP850"
2521	default_display_charset="ASCII"
2522	default_unix_charset="UTF-8"
2523	samba_cv_HAVE_NATIVE_ICONV=yes
2524	AC_MSG_WARN(assuming the libiconv in $iconv_current_LDFLAGS can convert)
2525	AC_MSG_WARN([$default_dos_charset, $default_display_charset and $default_unix_charset to UCS-16LE])
2526	fi
2527
2528	if test x"$samba_cv_HAVE_NATIVE_ICONV" = x"yes" ; then
2529
2530	CPPFLAGS=$save_CPPFLAGS
2531	LDFLAGS=$save_LDFLAGS
2532	LIBS=$save_LIBS
2533
2534	if test x"$iconv_current_LIBS" != x; then
2535	LIBS="$LIBS $iconv_current_LIBS"
2536	fi
2537
2538	# Add the flags we need to CPPFLAGS and LDFLAGS
2539	CPPFLAGS="$CPPFLAGS $iconv_current_CPPFLAGS"
2540	LDFLAGS="$LDFLAGS $iconv_current_LDFLAGS"
2541
2542	# Turn the #defines into string literals
2543	default_dos_charset="\"$default_dos_charset\""
2544	default_display_charset="\"$default_display_charset\""
2545	default_unix_charset="\"$default_unix_charset\""
2546
2547	AC_DEFINE(HAVE_NATIVE_ICONV,1,[Whether to use native iconv])
2548	AC_DEFINE_UNQUOTED(DEFAULT_DOS_CHARSET,$default_dos_charset,[Default dos charset name])
2549	AC_DEFINE_UNQUOTED(DEFAULT_DISPLAY_CHARSET,$default_display_charset,[Default display charset name])
2550	AC_DEFINE_UNQUOTED(DEFAULT_UNIX_CHARSET,$default_unix_charset,[Default unix charset name])
2551
2552	break
2553	fi
2554