1dnl @(#) Header: /tcpdump/master/tcpdump/aclocal.m4,v 1.116 2008-09-25 21:45:50 guy Exp (LBL)
2dnl
3dnl Copyright (c) 1995, 1996, 1997, 1998
4dnl	The Regents of the University of California.  All rights reserved.
5dnl
6dnl Redistribution and use in source and binary forms, with or without
7dnl modification, are permitted provided that: (1) source code distributions
8dnl retain the above copyright notice and this paragraph in its entirety, (2)
9dnl distributions including binary code include the above copyright notice and
10dnl this paragraph in its entirety in the documentation or other materials
11dnl provided with the distribution, and (3) all advertising materials mentioning
12dnl features or use of this software display the following acknowledgement:
13dnl ``This product includes software developed by the University of California,
14dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
15dnl the University nor the names of its contributors may be used to endorse
16dnl or promote products derived from this software without specific prior
17dnl written permission.
18dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21dnl
22dnl LBL autoconf macros
23dnl
24
25dnl
26dnl Do whatever AC_LBL_C_INIT work is necessary before using AC_PROG_CC.
27dnl
28dnl It appears that newer versions of autoconf (2.64 and later) will,
29dnl if you use AC_TRY_COMPILE in a macro, stick AC_PROG_CC at the
30dnl beginning of the macro, even if the macro itself calls AC_PROG_CC.
31dnl See the "Prerequisite Macros" and "Expanded Before Required" sections
32dnl in the Autoconf documentation.
33dnl
34dnl This causes a steaming heap of fail in our case, as we were, in
35dnl AC_LBL_C_INIT, doing the tests we now do in AC_LBL_C_INIT_BEFORE_CC,
36dnl calling AC_PROG_CC, and then doing the tests we now do in
37dnl AC_LBL_C_INIT.  Now, we run AC_LBL_C_INIT_BEFORE_CC, AC_PROG_CC,
38dnl and AC_LBL_C_INIT at the top level.
39dnl
40AC_DEFUN(AC_LBL_C_INIT_BEFORE_CC,
41    [AC_PREREQ(2.50)
42    AC_BEFORE([$0], [AC_LBL_C_INIT])
43    AC_BEFORE([$0], [AC_PROG_CC])
44    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
45    AC_BEFORE([$0], [AC_LBL_DEVEL])
46    AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
47    $1="-O"
48    $2=""
49    if test "${srcdir}" != "." ; then
50	    $2="-I\$(srcdir)"
51    fi
52    if test "${CFLAGS+set}" = set; then
53	    LBL_CFLAGS="$CFLAGS"
54    fi
55    if test -z "$CC" ; then
56	    case "$host_os" in
57
58	    bsdi*)
59		    AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
60		    if test $SHLICC2 = yes ; then
61			    CC=shlicc2
62			    export CC
63		    fi
64		    ;;
65	    esac
66    fi
67    if test -z "$CC" -a "$with_gcc" = no ; then
68	    CC=cc
69	    export CC
70    fi
71])
72
73dnl
74dnl Determine which compiler we're using (cc or gcc)
75dnl If using gcc, determine the version number
76dnl If using cc, require that it support ansi prototypes
77dnl If using gcc, use -O2 (otherwise use -O)
78dnl If using cc, explicitly specify /usr/local/include
79dnl
80dnl usage:
81dnl
82dnl	AC_LBL_C_INIT(copt, incls)
83dnl
84dnl results:
85dnl
86dnl	$1 (copt set)
87dnl	$2 (incls set)
88dnl	CC
89dnl	LDFLAGS
90dnl	ac_cv_lbl_gcc_vers
91dnl	LBL_CFLAGS
92dnl
93AC_DEFUN(AC_LBL_C_INIT,
94    [AC_PREREQ(2.50)
95    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
96    AC_BEFORE([$0], [AC_LBL_DEVEL])
97    AC_BEFORE([$0], [AC_LBL_SHLIBS_INIT])
98    if test "$GCC" = yes ; then
99	    if test "$SHLICC2" = yes ; then
100		    ac_cv_lbl_gcc_vers=2
101		    $1="-O2"
102	    else
103		    AC_MSG_CHECKING(gcc version)
104		    AC_CACHE_VAL(ac_cv_lbl_gcc_vers,
105			ac_cv_lbl_gcc_vers=`$CC -v 2>&1 | \
106			    sed -e '/^gcc version /!d' \
107				-e 's/^gcc version //' \
108				-e 's/ .*//' -e 's/^[[[^0-9]]]*//' \
109				-e 's/\..*//'`)
110		    AC_MSG_RESULT($ac_cv_lbl_gcc_vers)
111		    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
112			    $1="-O2"
113		    fi
114	    fi
115    else
116	    AC_MSG_CHECKING(that $CC handles ansi prototypes)
117	    AC_CACHE_VAL(ac_cv_lbl_cc_ansi_prototypes,
118		AC_TRY_COMPILE(
119		    [#include <sys/types.h>],
120		    [int frob(int, char *)],
121		    ac_cv_lbl_cc_ansi_prototypes=yes,
122		    ac_cv_lbl_cc_ansi_prototypes=no))
123	    AC_MSG_RESULT($ac_cv_lbl_cc_ansi_prototypes)
124	    if test $ac_cv_lbl_cc_ansi_prototypes = no ; then
125		    case "$host_os" in
126
127		    hpux*)
128			    AC_MSG_CHECKING(for HP-UX ansi compiler ($CC -Aa -D_HPUX_SOURCE))
129			    savedcflags="$CFLAGS"
130			    CFLAGS="-Aa -D_HPUX_SOURCE $CFLAGS"
131			    AC_CACHE_VAL(ac_cv_lbl_cc_hpux_cc_aa,
132				AC_TRY_COMPILE(
133				    [#include <sys/types.h>],
134				    [int frob(int, char *)],
135				    ac_cv_lbl_cc_hpux_cc_aa=yes,
136				    ac_cv_lbl_cc_hpux_cc_aa=no))
137			    AC_MSG_RESULT($ac_cv_lbl_cc_hpux_cc_aa)
138			    if test $ac_cv_lbl_cc_hpux_cc_aa = no ; then
139				    AC_MSG_ERROR(see the INSTALL doc for more info)
140			    fi
141			    CFLAGS="$savedcflags"
142			    $1="-Aa $$1"
143			    AC_DEFINE(_HPUX_SOURCE,1,[needed on HP-UX])
144			    ;;
145
146		    osf*)
147			    AC_MSG_CHECKING(for ansi mode in DEC compiler ($CC -std1))
148			    savedcflags="$CFLAGS"
149			    CFLAGS="-std1"
150			    AC_CACHE_VAL(ac_cv_lbl_cc_osf1_cc_std1,
151				AC_TRY_COMPILE(
152				    [#include <sys/types.h>],
153				    [int frob(int, char *)],
154				    ac_cv_lbl_cc_osf1_cc_std1=yes,
155				    ac_cv_lbl_cc_osf1_cc_std1=no))
156			    AC_MSG_RESULT($ac_cv_lbl_cc_osf1_cc_std1)
157			    if test $ac_cv_lbl_cc_osf1_cc_std1 = no ; then
158				    AC_MSG_ERROR(see the INSTALL doc for more info)
159			    fi
160			    CFLAGS="$savedcflags"
161			    $1="-std1 $$1"
162			    ;;
163
164		    *)
165			    AC_MSG_ERROR(see the INSTALL doc for more info)
166			    ;;
167		    esac
168	    fi
169	    $2="$$2 -I/usr/local/include"
170	    LDFLAGS="$LDFLAGS -L/usr/local/lib"
171
172	    case "$host_os" in
173
174	    irix*)
175		    $1="$$1 -xansi -signed -O"
176		    ;;
177
178	    osf*)
179	    	    #
180		    # Presumed to be DEC OSF/1, Digital UNIX, or
181		    # Tru64 UNIX.
182		    #
183		    $1="$$1 -O"
184		    ;;
185
186	    ultrix*)
187		    AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
188		    AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
189			AC_TRY_COMPILE(
190			    [#include <sys/types.h>],
191			    [struct a { int b; };
192			    void c(const struct a *)],
193			    ac_cv_lbl_cc_const_proto=yes,
194			    ac_cv_lbl_cc_const_proto=no))
195		    AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
196		    if test $ac_cv_lbl_cc_const_proto = no ; then
197			    AC_DEFINE(const,[],
198			        [to handle Ultrix compilers that don't support const in prototypes])
199		    fi
200		    ;;
201	    esac
202    fi
203])
204
205#
206# Try compiling a sample of the type of code that appears in
207# gencode.c with "inline", "__inline__", and "__inline".
208#
209# Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
210# as it just tests whether a function returning "int" can be inlined;
211# at least some versions of HP's C compiler can inline that, but can't
212# inline a function that returns a struct pointer.
213#
214# Make sure we use the V_CCOPT flags, because some of those might
215# disable inlining.
216#
217AC_DEFUN(AC_LBL_C_INLINE,
218    [AC_MSG_CHECKING(for inline)
219    save_CFLAGS="$CFLAGS"
220    CFLAGS="$V_CCOPT"
221    AC_CACHE_VAL(ac_cv_lbl_inline, [
222	ac_cv_lbl_inline=""
223	ac_lbl_cc_inline=no
224	for ac_lbl_inline in inline __inline__ __inline
225	do
226	    AC_TRY_COMPILE(
227		[#define inline $ac_lbl_inline
228		static inline struct iltest *foo(void);
229		struct iltest {
230		    int iltest1;
231		    int iltest2;
232		};
233
234		static inline struct iltest *
235		foo()
236		{
237		    static struct iltest xxx;
238
239		    return &xxx;
240		}],,ac_lbl_cc_inline=yes,)
241	    if test "$ac_lbl_cc_inline" = yes ; then
242		break;
243	    fi
244	done
245	if test "$ac_lbl_cc_inline" = yes ; then
246	    ac_cv_lbl_inline=$ac_lbl_inline
247	fi])
248    CFLAGS="$save_CFLAGS"
249    if test ! -z "$ac_cv_lbl_inline" ; then
250	AC_MSG_RESULT($ac_cv_lbl_inline)
251    else
252	AC_MSG_RESULT(no)
253    fi
254    AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
255
256dnl
257dnl Use pfopen.c if available and pfopen() not in standard libraries
258dnl Require libpcap
259dnl Look for libpcap in ..
260dnl Use the installed libpcap if there is no local version
261dnl
262dnl usage:
263dnl
264dnl	AC_LBL_LIBPCAP(pcapdep, incls)
265dnl
266dnl results:
267dnl
268dnl	$1 (pcapdep set)
269dnl	$2 (incls appended)
270dnl	LIBS
271dnl	LBL_LIBS
272dnl
273AC_DEFUN(AC_LBL_LIBPCAP,
274    [AC_REQUIRE([AC_LBL_LIBRARY_NET])
275    dnl
276    dnl save a copy before locating libpcap.a
277    dnl
278    LBL_LIBS="$LIBS"
279    pfopen=/usr/examples/packetfilter/pfopen.c
280    if test -f $pfopen ; then
281	    AC_CHECK_FUNCS(pfopen)
282	    if test $ac_cv_func_pfopen = "no" ; then
283		    AC_MSG_RESULT(Using $pfopen)
284		    LIBS="$LIBS $pfopen"
285	    fi
286    fi
287    AC_MSG_CHECKING(for local pcap library)
288    libpcap=FAIL
289    lastdir=FAIL
290    places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
291	egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT)?$'`
292    for dir in $places $srcdir/../libpcap $srcdir/libpcap ; do
293	    basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//' | \
294	        sed -e 's/-PRE-GIT$//' `
295	    if test $lastdir = $basedir ; then
296		    dnl skip alphas when an actual release is present
297		    continue;
298	    fi
299	    lastdir=$dir
300	    if test -r $dir/libpcap.a ; then
301		    libpcap=$dir/libpcap.a
302		    d=$dir
303		    dnl continue and select the last one that exists
304	    fi
305    done
306    if test $libpcap = FAIL ; then
307	    AC_MSG_RESULT(not found)
308
309	    #
310	    # Look for pcap-config.
311	    #
312	    AC_PATH_PROG(PCAP_CONFIG, pcap-config)
313	    if test -n "$PCAP_CONFIG" ; then
314		#
315		# Found - use it to get the include flags for
316		# libpcap and the flags to link with libpcap.
317		#
318		$2="`\"$PCAP_CONFIG\" --cflags` $$2"
319		libpcap="`\"$PCAP_CONFIG\" --libs`"
320	    else
321		#
322		# Not found; look for pcap.
323		#
324		AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
325		if test $libpcap = FAIL ; then
326		    AC_MSG_ERROR(see the INSTALL doc for more info)
327		fi
328		dnl
329		dnl Some versions of Red Hat Linux put "pcap.h" in
330		dnl "/usr/include/pcap"; had the LBL folks done so,
331		dnl that would have been a good idea, but for
332		dnl the Red Hat folks to do so just breaks source
333		dnl compatibility with other systems.
334		dnl
335		dnl We work around this by assuming that, as we didn't
336		dnl find a local libpcap, libpcap is in /usr/lib or
337		dnl /usr/local/lib and that the corresponding header
338		dnl file is under one of those directories; if we don't
339		dnl find it in either of those directories, we check to
340		dnl see if it's in a "pcap" subdirectory of them and,
341		dnl if so, add that subdirectory to the "-I" list.
342		dnl
343		dnl (We now also put pcap.h in /usr/include/pcap, but we
344		dnl leave behind a /usr/include/pcap.h that includes it,
345		dnl so you can still just include <pcap.h>.)
346		dnl
347		AC_MSG_CHECKING(for extraneous pcap header directories)
348		if test \( ! -r /usr/local/include/pcap.h \) -a \
349			\( ! -r /usr/include/pcap.h \); then
350		    if test -r /usr/local/include/pcap/pcap.h; then
351			d="/usr/local/include/pcap"
352		    elif test -r /usr/include/pcap/pcap.h; then
353			d="/usr/include/pcap"
354		    fi
355		fi
356		if test -z "$d" ; then
357		    AC_MSG_RESULT(not found)
358		else
359		    $2="-I$d $$2"
360		    AC_MSG_RESULT(found -- -I$d added)
361		fi
362	    fi
363    else
364	    $1=$libpcap
365	    places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
366    	 		egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
367	    if test -r $d/pcap.h; then
368		    $2="-I$d $$2"
369	    elif test -r $places/pcap.h; then
370		    $2="-I$places $$2"
371	    else
372                    AC_MSG_ERROR(cannot find pcap.h, see INSTALL)
373 	    fi
374	    AC_MSG_RESULT($libpcap)
375	    AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $d)
376	    if test -n "$PCAP_CONFIG"; then
377		#
378		# The libpcap directory has a pcap-config script.
379		# Use it to get any additioal libraries needed
380		# to link with the libpcap archive library in
381		# that directory
382		#
383		libpcap="$libpcap `\"$PCAP_CONFIG\" --additional-libs --static`"
384	    fi
385    fi
386    LIBS="$libpcap $LIBS"
387    if ! test -n "$PCAP_CONFIG" ; then
388	#
389	# We don't have pcap-config; find out any additional link flags
390	# we need.  (If we have pcap-config, we assume it tells us what
391	# we need.)
392	#
393	case "$host_os" in
394
395	aix*)
396	    #
397	    # If libpcap is DLPI-based, we have to use /lib/pse.exp if
398	    # present, as we use the STREAMS routines.
399	    #
400	    # (XXX - true only if we're linking with a static libpcap?)
401	    #
402	    pseexe="/lib/pse.exp"
403	    AC_MSG_CHECKING(for $pseexe)
404	    if test -f $pseexe ; then
405		    AC_MSG_RESULT(yes)
406		    LIBS="$LIBS -I:$pseexe"
407	    fi
408
409	    #
410	    # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as
411	    # we use them to load the BPF module.
412	    #
413	    # (XXX - true only if we're linking with a static libpcap?)
414	    #
415	    LIBS="$LIBS -lodm -lcfg"
416	    ;;
417	esac
418    fi
419
420    dnl
421    dnl Check for "pcap_list_datalinks()", "pcap_set_datalink()",
422    dnl and "pcap_datalink_name_to_val()", and use substitute versions
423    dnl if they're not present.
424    dnl
425    AC_CHECK_FUNC(pcap_list_datalinks,
426	AC_DEFINE(HAVE_PCAP_LIST_DATALINKS),
427	[
428	    AC_LIBOBJ(datalinks)
429	])
430    AC_CHECK_FUNC(pcap_set_datalink,
431	AC_DEFINE(HAVE_PCAP_SET_DATALINK))
432    AC_CHECK_FUNC(pcap_datalink_name_to_val,
433	[
434	    AC_DEFINE(HAVE_PCAP_DATALINK_NAME_TO_VAL)
435	    AC_CHECK_FUNC(pcap_datalink_val_to_description,
436		AC_DEFINE(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION),
437		[
438		    AC_LIBOBJ(dlnames)
439		])
440	],
441	[
442	    AC_LIBOBJ(dlnames)
443	])
444
445    dnl
446    dnl Check for "pcap_breakloop()"; you can't substitute for it if
447    dnl it's absent (it has hooks into the live capture routines),
448    dnl so just define the HAVE_ value if it's there.
449    dnl
450    AC_CHECK_FUNCS(pcap_breakloop)
451
452    dnl
453    dnl Check for "pcap_dump_ftell()" and use a substitute version
454    dnl if it's not present.
455    AC_CHECK_FUNC(pcap_dump_ftell,
456	AC_DEFINE(HAVE_PCAP_DUMP_FTELL),
457	[
458	    AC_LIBOBJ(pcap_dump_ftell)
459	])
460])
461
462dnl
463dnl Define RETSIGTYPE and RETSIGVAL
464dnl
465dnl usage:
466dnl
467dnl	AC_LBL_TYPE_SIGNAL
468dnl
469dnl results:
470dnl
471dnl	RETSIGTYPE (defined)
472dnl	RETSIGVAL (defined)
473dnl
474AC_DEFUN(AC_LBL_TYPE_SIGNAL,
475    [AC_BEFORE([$0], [AC_LBL_LIBPCAP])
476    AC_TYPE_SIGNAL
477    if test "$ac_cv_type_signal" = void ; then
478	    AC_DEFINE(RETSIGVAL,[],[return value of signal handlers])
479    else
480	    AC_DEFINE(RETSIGVAL,(0),[return value of signal handlers])
481    fi
482    case "$host_os" in
483
484    irix*)
485	    AC_DEFINE(_BSD_SIGNALS,1,[get BSD semantics on Irix])
486	    ;;
487
488    *)
489	    dnl prefer sigaction() to sigset()
490	    AC_CHECK_FUNCS(sigaction)
491	    if test $ac_cv_func_sigaction = no ; then
492		    AC_CHECK_FUNCS(sigset)
493	    fi
494	    ;;
495    esac])
496
497dnl
498dnl If using gcc, make sure we have ANSI ioctl definitions
499dnl
500dnl usage:
501dnl
502dnl	AC_LBL_FIXINCLUDES
503dnl
504AC_DEFUN(AC_LBL_FIXINCLUDES,
505    [if test "$GCC" = yes ; then
506	    AC_MSG_CHECKING(for ANSI ioctl definitions)
507	    AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
508		AC_TRY_COMPILE(
509		    [/*
510		     * This generates a "duplicate case value" when fixincludes
511		     * has not be run.
512		     */
513#		include <sys/types.h>
514#		include <sys/time.h>
515#		include <sys/ioctl.h>
516#		ifdef HAVE_SYS_IOCCOM_H
517#		include <sys/ioccom.h>
518#		endif],
519		    [switch (0) {
520		    case _IO('A', 1):;
521		    case _IO('B', 1):;
522		    }],
523		    ac_cv_lbl_gcc_fixincludes=yes,
524		    ac_cv_lbl_gcc_fixincludes=no))
525	    AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
526	    if test $ac_cv_lbl_gcc_fixincludes = no ; then
527		    # Don't cache failure
528		    unset ac_cv_lbl_gcc_fixincludes
529		    AC_MSG_ERROR(see the INSTALL for more info)
530	    fi
531    fi])
532
533dnl
534dnl Checks to see if union wait is used with WEXITSTATUS()
535dnl
536dnl usage:
537dnl
538dnl	AC_LBL_UNION_WAIT
539dnl
540dnl results:
541dnl
542dnl	DECLWAITSTATUS (defined)
543dnl
544AC_DEFUN(AC_LBL_UNION_WAIT,
545    [AC_MSG_CHECKING(if union wait is used)
546    AC_CACHE_VAL(ac_cv_lbl_union_wait,
547	AC_TRY_COMPILE([
548#	include <sys/types.h>
549#	include <sys/wait.h>],
550	    [int status;
551	    u_int i = WEXITSTATUS(status);
552	    u_int j = waitpid(0, &status, 0);],
553	    ac_cv_lbl_union_wait=no,
554	    ac_cv_lbl_union_wait=yes))
555    AC_MSG_RESULT($ac_cv_lbl_union_wait)
556    if test $ac_cv_lbl_union_wait = yes ; then
557	    AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])
558    else
559	    AC_DEFINE(DECLWAITSTATUS,int,[type for wait])
560    fi])
561
562dnl
563dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
564dnl
565dnl usage:
566dnl
567dnl	AC_LBL_SOCKADDR_SA_LEN
568dnl
569dnl results:
570dnl
571dnl	HAVE_SOCKADDR_SA_LEN (defined)
572dnl
573AC_DEFUN(AC_LBL_SOCKADDR_SA_LEN,
574    [AC_MSG_CHECKING(if sockaddr struct has the sa_len member)
575    AC_CACHE_VAL(ac_cv_lbl_sockaddr_has_sa_len,
576	AC_TRY_COMPILE([
577#	include <sys/types.h>
578#	include <sys/socket.h>],
579	[u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
580	ac_cv_lbl_sockaddr_has_sa_len=yes,
581	ac_cv_lbl_sockaddr_has_sa_len=no))
582    AC_MSG_RESULT($ac_cv_lbl_sockaddr_has_sa_len)
583    if test $ac_cv_lbl_sockaddr_has_sa_len = yes ; then
584	    AC_DEFINE(HAVE_SOCKADDR_SA_LEN,1,[if struct sockaddr has the sa_len member])
585    fi])
586
587dnl
588dnl Checks to see if -R is used
589dnl
590dnl usage:
591dnl
592dnl	AC_LBL_HAVE_RUN_PATH
593dnl
594dnl results:
595dnl
596dnl	ac_cv_lbl_have_run_path (yes or no)
597dnl
598AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
599    [AC_MSG_CHECKING(for ${CC-cc} -R)
600    AC_CACHE_VAL(ac_cv_lbl_have_run_path,
601	[echo 'main(){}' > conftest.c
602	${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
603	if test ! -s conftest.out ; then
604		ac_cv_lbl_have_run_path=yes
605	else
606		ac_cv_lbl_have_run_path=no
607	fi
608	rm -f -r conftest*])
609    AC_MSG_RESULT($ac_cv_lbl_have_run_path)
610    ])
611
612dnl
613dnl Check whether a given format can be used to print 64-bit integers
614dnl
615AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,
616  [
617    AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])
618    AC_RUN_IFELSE(
619      [
620	AC_LANG_SOURCE(
621	  [[
622#	    ifdef HAVE_INTTYPES_H
623	    #include <inttypes.h>
624#	    endif
625#	    ifdef HAVE_SYS_BITYPES_H
626            #include <sys/bitypes.h>
627#	    endif
628	    #include <stdio.h>
629	    #include <sys/types.h>
630
631	    main()
632	    {
633	      u_int64_t t = 1;
634	      char strbuf[16+1];
635	      sprintf(strbuf, "%016$1x", t << 32);
636	      if (strcmp(strbuf, "0000000100000000") == 0)
637		exit(0);
638	      else
639		exit(1);
640	    }
641	  ]])
642      ],
643      [
644	AC_DEFINE(PRId64, "$1d")
645	AC_DEFINE(PRIo64, "$1o")
646	AC_DEFINE(PRIx64, "$1x")
647	AC_DEFINE(PRIu64, "$1u")
648	AC_MSG_RESULT(yes)
649      ],
650      [
651	AC_MSG_RESULT(no)
652	$2
653      ])
654  ])
655
656dnl
657dnl Checks to see if unaligned memory accesses fail
658dnl
659dnl usage:
660dnl
661dnl	AC_LBL_UNALIGNED_ACCESS
662dnl
663dnl results:
664dnl
665dnl	LBL_ALIGN (DEFINED)
666dnl
667AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,
668    [AC_MSG_CHECKING(if unaligned accesses fail)
669    AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,
670	[case "$host_cpu" in
671
672	#
673	# These are CPU types where:
674	#
675	#	the CPU faults on an unaligned access, but at least some
676	#	OSes that support that CPU catch the fault and simulate
677	#	the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -
678	#	the simulation is slow, so we don't want to use it;
679	#
680	#	the CPU, I infer (from the old
681	#
682	# XXX: should also check that they don't do weird things (like on arm)
683	#
684	#	comment) doesn't fault on unaligned accesses, but doesn't
685	#	do a normal unaligned fetch, either (e.g., presumably, ARM);
686	#
687	#	for whatever reason, the test program doesn't work
688	#	(this has been claimed to be the case for several of those
689	#	CPUs - I don't know what the problem is; the problem
690	#	was reported as "the test program dumps core" for SuperH,
691	#	but that's what the test program is *supposed* to do -
692	#	it dumps core before it writes anything, so the test
693	#	for an empty output file should find an empty output
694	#	file and conclude that unaligned accesses don't work).
695	#
696	# This run-time test won't work if you're cross-compiling, so
697	# in order to support cross-compiling for a particular CPU,
698	# we have to wire in the list of CPU types anyway, as far as
699	# I know, so perhaps we should just have a set of CPUs on
700	# which we know it doesn't work, a set of CPUs on which we
701	# know it does work, and have the script just fail on other
702	# cpu types and update it when such a failure occurs.
703	#
704	alpha*|arm*|bfin*|hp*|mips*|sh*|sparc*|ia64|nv1)
705		ac_cv_lbl_unaligned_fail=yes
706		;;
707
708	*)
709		cat >conftest.c <<EOF
710#		include <sys/types.h>
711#		include <sys/wait.h>
712#		include <stdio.h>
713		unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
714		main() {
715		unsigned int i;
716		pid_t pid;
717		int status;
718		/* avoid "core dumped" message */
719		pid = fork();
720		if (pid <  0)
721			exit(2);
722		if (pid > 0) {
723			/* parent */
724			pid = waitpid(pid, &status, 0);
725			if (pid < 0)
726				exit(3);
727			exit(!WIFEXITED(status));
728		}
729		/* child */
730		i = *(unsigned int *)&a[[1]];
731		printf("%d\n", i);
732		exit(0);
733		}
734EOF
735		${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
736		    conftest.c $LIBS >/dev/null 2>&1
737		if test ! -x conftest ; then
738			dnl failed to compile for some reason
739			ac_cv_lbl_unaligned_fail=yes
740		else
741			./conftest >conftest.out
742			if test ! -s conftest.out ; then
743				ac_cv_lbl_unaligned_fail=yes
744			else
745				ac_cv_lbl_unaligned_fail=no
746			fi
747		fi
748		rm -f -r conftest* core core.conftest
749		;;
750	esac])
751    AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)
752    if test $ac_cv_lbl_unaligned_fail = yes ; then
753	    AC_DEFINE(LBL_ALIGN,1,[if unaligned access fails])
754    fi])
755
756dnl
757dnl If using gcc and the file .devel exists:
758dnl	Compile with -g (if supported) and -Wall
759dnl	If using gcc 2 or later, do extra prototype checking and some other
760dnl	checks
761dnl	If an os prototype include exists, symlink os-proto.h to it
762dnl
763dnl usage:
764dnl
765dnl	AC_LBL_DEVEL(copt)
766dnl
767dnl results:
768dnl
769dnl	$1 (copt appended)
770dnl	HAVE_OS_PROTO_H (defined)
771dnl	os-proto.h (symlinked)
772dnl
773AC_DEFUN(AC_LBL_DEVEL,
774    [rm -f os-proto.h
775    if test "${LBL_CFLAGS+set}" = set; then
776	    $1="$$1 ${LBL_CFLAGS}"
777    fi
778    if test -f .devel ; then
779	    if test "$GCC" = yes ; then
780		    if test "${LBL_CFLAGS+set}" != set; then
781			    if test "$ac_cv_prog_cc_g" = yes ; then
782				    $1="-g $$1"
783			    fi
784			    $1="$$1 -Wall"
785			    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
786				    $1="$$1 -Wmissing-prototypes -Wstrict-prototypes -Wwrite-strings -Wpointer-arith -W"
787			    fi
788		    fi
789	    else
790		    case "$host_os" in
791
792		    irix6*)
793			    V_CCOPT="$V_CCOPT -n32"
794			    ;;
795
796		    *)
797			    ;;
798		    esac
799	    fi
800	    os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
801	    name="lbl/os-$os.h"
802	    if test -f $name ; then
803		    ln -s $name os-proto.h
804		    AC_DEFINE(HAVE_OS_PROTO_H, 1,
805			[if there's an os_proto.h for this platform, to use additional prototypes])
806	    else
807		    AC_MSG_WARN(can't find $name)
808	    fi
809    fi])
810
811dnl
812dnl Improved version of AC_CHECK_LIB
813dnl
814dnl Thanks to John Hawkinson (jhawk@mit.edu)
815dnl
816dnl usage:
817dnl
818dnl	AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
819dnl	    ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
820dnl
821dnl results:
822dnl
823dnl	LIBS
824dnl
825dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
826dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
827dnl We keep it around for reference purposes in case it's ever
828dnl useful in the future.
829dnl
830
831define(AC_LBL_CHECK_LIB,
832[AC_MSG_CHECKING([for $2 in -l$1])
833dnl Use a cache variable name containing the library, function
834dnl name, and extra libraries to link with, because the test really is
835dnl for library $1 defining function $2, when linked with potinal
836dnl library $5, not just for library $1.  Separate tests with the same
837dnl $1 and different $2's or $5's may have different results.
838ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
839AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
840[ac_save_LIBS="$LIBS"
841LIBS="-l$1 $5 $LIBS"
842AC_TRY_LINK(dnl
843ifelse([$2], [main], , dnl Avoid conflicting decl of main.
844[/* Override any gcc2 internal prototype to avoid an error.  */
845]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
846extern "C"
847#endif
848])dnl
849[/* We use char because int might match the return type of a gcc2
850    builtin and then its argument prototype would still apply.  */
851char $2();
852]),
853	    [$2()],
854	    eval "ac_cv_lbl_lib_$ac_lib_var=yes",
855	    eval "ac_cv_lbl_lib_$ac_lib_var=no")
856LIBS="$ac_save_LIBS"
857])dnl
858if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
859  AC_MSG_RESULT(yes)
860  ifelse([$3], ,
861[changequote(, )dnl
862  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
863    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
864changequote([, ])dnl
865  AC_DEFINE_UNQUOTED($ac_tr_lib)
866  LIBS="-l$1 $LIBS"
867], [$3])
868else
869  AC_MSG_RESULT(no)
870ifelse([$4], , , [$4
871])dnl
872fi
873])
874
875dnl
876dnl AC_LBL_LIBRARY_NET
877dnl
878dnl This test is for network applications that need socket() and
879dnl gethostbyname() -ish functions.  Under Solaris, those applications
880dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
881dnl with "-lnsl" but should *not* link with "-lsocket" because
882dnl libsocket.a breaks a number of things (for instance:
883dnl gethostbyname() under IRIX 5.2, and snoop sockets under most
884dnl versions of IRIX).
885dnl
886dnl Unfortunately, many application developers are not aware of this,
887dnl and mistakenly write tests that cause -lsocket to be used under
888dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
889dnl under operating systems where neither are necessary (or useful),
890dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
891dnl
892dnl This test exists so that every application developer does not test
893dnl this in a different, and subtly broken fashion.
894
895dnl It has been argued that this test should be broken up into two
896dnl seperate tests, one for the resolver libraries, and one for the
897dnl libraries necessary for using Sockets API. Unfortunately, the two
898dnl are carefully intertwined and allowing the autoconf user to use
899dnl them independantly potentially results in unfortunate ordering
900dnl dependancies -- as such, such component macros would have to
901dnl carefully use indirection and be aware if the other components were
902dnl executed. Since other autoconf macros do not go to this trouble,
903dnl and almost no applications use sockets without the resolver, this
904dnl complexity has not been implemented.
905dnl
906dnl The check for libresolv is in case you are attempting to link
907dnl statically and happen to have a libresolv.a lying around (and no
908dnl libnsl.a).
909dnl
910AC_DEFUN(AC_LBL_LIBRARY_NET, [
911    # Most operating systems have gethostbyname() in the default searched
912    # libraries (i.e. libc):
913    # Some OSes (eg. Solaris) place it in libnsl
914    # Some strange OSes (SINIX) have it in libsocket:
915    AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)
916    # Unfortunately libsocket sometimes depends on libnsl and
917    # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
918    if test "$ac_cv_search_gethostbyname" = "no"
919    then
920	AC_CHECK_LIB(socket, gethostbyname,
921                     LIBS="-lsocket -lnsl $LIBS", , -lnsl)
922    fi
923    AC_SEARCH_LIBS(socket, socket, ,
924	AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
925    # DLPI needs putmsg under HPUX so test for -lstr while we're at it
926    AC_SEARCH_LIBS(putmsg, str)
927    ])
928
929dnl Copyright (c) 1999 WIDE Project. All rights reserved.
930dnl
931dnl Redistribution and use in source and binary forms, with or without
932dnl modification, are permitted provided that the following conditions
933dnl are met:
934dnl 1. Redistributions of source code must retain the above copyright
935dnl    notice, this list of conditions and the following disclaimer.
936dnl 2. Redistributions in binary form must reproduce the above copyright
937dnl    notice, this list of conditions and the following disclaimer in the
938dnl    documentation and/or other materials provided with the distribution.
939dnl 3. Neither the name of the project nor the names of its contributors
940dnl    may be used to endorse or promote products derived from this software
941dnl    without specific prior written permission.
942dnl 
943dnl THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
944dnl ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
945dnl IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
946dnl ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
947dnl FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
948dnl DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
949dnl OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
950dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
951dnl LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
952dnl OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
953dnl SUCH DAMAGE.
954
955dnl
956dnl Checks to see if AF_INET6 is defined
957AC_DEFUN(AC_CHECK_AF_INET6, [
958	AC_MSG_CHECKING(for AF_INET6)
959	AC_CACHE_VAL($1,
960	AC_TRY_COMPILE([
961#		include <sys/types.h>
962#		include <sys/socket.h>],
963		[int a = AF_INET6],
964		$1=yes,
965		$1=no))
966	AC_MSG_RESULT($$1)
967		if test $$1 = yes ; then
968			AC_DEFINE(HAVE_AF_INET6)
969	fi
970])
971
972dnl
973dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
974dnl borrowed from LBL libpcap
975AC_DEFUN(AC_CHECK_SA_LEN, [
976	AC_MSG_CHECKING(if sockaddr struct has sa_len member)
977	AC_CACHE_VAL($1,
978	AC_TRY_COMPILE([
979#		include <sys/types.h>
980#		include <sys/socket.h>],
981		[u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
982		$1=yes,
983		$1=no))
984	AC_MSG_RESULT($$1)
985		if test $$1 = yes ; then
986			AC_DEFINE(HAVE_SOCKADDR_SA_LEN)
987	fi
988])
989
990dnl
991dnl Checks for addrinfo structure
992AC_DEFUN(AC_STRUCT_ADDRINFO, [
993	AC_MSG_CHECKING(for addrinfo)
994	AC_CACHE_VAL($1,
995	AC_TRY_COMPILE([
996#		include <netdb.h>],
997		[struct addrinfo a],
998		$1=yes,
999		$1=no))
1000	AC_MSG_RESULT($$1)
1001	if test $$1 = yes; then
1002		AC_DEFINE(HAVE_ADDRINFO)
1003	else
1004		AC_DEFINE(NEED_ADDRINFO_H)
1005	fi
1006])
1007
1008dnl
1009dnl Checks for NI_MAXSERV
1010AC_DEFUN(AC_NI_MAXSERV, [
1011	AC_MSG_CHECKING(for NI_MAXSERV)
1012	AC_CACHE_VAL($1,
1013	AC_EGREP_CPP(yes, [#include <netdb.h>
1014#ifdef NI_MAXSERV
1015yes
1016#endif],
1017		$1=yes,
1018		$1=no))
1019	AC_MSG_RESULT($$1)
1020	if test $$1 != yes; then
1021		AC_DEFINE(NEED_ADDRINFO_H)
1022	fi
1023])
1024
1025dnl
1026dnl Checks for NI_NAMEREQD
1027AC_DEFUN(AC_NI_NAMEREQD, [
1028	AC_MSG_CHECKING(for NI_NAMEREQD)
1029	AC_CACHE_VAL($1,
1030	AC_EGREP_CPP(yes, [#include <netdb.h>
1031#ifdef NI_NOFQDN
1032yes
1033#endif],
1034		$1=yes,
1035		$1=no))
1036	AC_MSG_RESULT($$1)
1037	if test $$1 != yes; then
1038		AC_DEFINE(NEED_ADDRINFO_H)
1039	fi
1040])
1041
1042dnl
1043dnl Checks for sockaddr_storage structure
1044AC_DEFUN(AC_STRUCT_SA_STORAGE, [
1045	AC_MSG_CHECKING(for sockaddr_storage)
1046	AC_CACHE_VAL($1,
1047	AC_TRY_COMPILE([
1048#		include <sys/types.h>
1049#		include <sys/socket.h>],
1050		[struct sockaddr_storage s],
1051		$1=yes,
1052		$1=no))
1053	AC_MSG_RESULT($$1)
1054	if test $$1 = yes; then
1055		AC_DEFINE(HAVE_SOCKADDR_STORAGE)
1056	fi
1057])
1058
1059dnl
1060dnl Checks for macro of IP address size
1061AC_DEFUN(AC_CHECK_ADDRSZ, [
1062	$1=yes
1063dnl check for INADDRSZ
1064	AC_MSG_CHECKING(for INADDRSZ)
1065	AC_CACHE_VAL(ac_cv_inaddrsz,
1066	AC_TRY_COMPILE([
1067#		include <arpa/nameser.h>],
1068		[int a = INADDRSZ],
1069		ac_cv_inaddrsz=yes,
1070		ac_cv_inaddrsz=no))
1071	AC_MSG_RESULT($ac_cv_inaddrsz)
1072	if test $ac_cv_inaddrsz = yes; then
1073		AC_DEFINE(HAVE_INADDRSZ)
1074	else
1075		$1=no
1076	fi
1077dnl check for IN6ADDRSZ
1078	AC_MSG_CHECKING(for IN6ADDRSZ)
1079	AC_CACHE_VAL(ac_cv_in6addrsz,
1080	AC_TRY_COMPILE([
1081#		include <arpa/nameser.h>],
1082		[int a = IN6ADDRSZ],
1083		ac_cv_in6addrsz=yes,
1084		ac_cv_in6addrsz=no))
1085	AC_MSG_RESULT($ac_cv_in6addrsz)
1086	if test $ac_cv_in6addrsz = yes; then
1087		AC_DEFINE(HAVE_IN6ADDRSZ)
1088	else
1089		$1=no
1090	fi
1091])
1092
1093dnl
1094dnl check for RES_USE_INET6
1095AC_DEFUN(AC_CHECK_RES_USE_INET6, [
1096	AC_MSG_CHECKING(for RES_USE_INET6)
1097	AC_CACHE_VAL($1,
1098	AC_TRY_COMPILE([
1099#		include <sys/types.h>
1100#		include <netinet/in.h>
1101#		include <resolv.h>],
1102		[int a = RES_USE_INET6],
1103		$1=yes,
1104		$1=no))
1105	AC_MSG_RESULT($$1)
1106	if test $$1 = yes; then
1107		AC_DEFINE(HAVE_RES_USE_INET6)
1108	fi
1109])
1110
1111dnl
1112dnl check for AAAA
1113AC_DEFUN(AC_CHECK_AAAA, [
1114	AC_MSG_CHECKING(for AAAA)
1115	AC_CACHE_VAL($1,
1116	AC_TRY_COMPILE([
1117#		include <sys/types.h>
1118#		include <arpa/nameser.h>],
1119		[int a = T_AAAA],
1120		$1=yes,
1121		$1=no))
1122	AC_MSG_RESULT($$1)
1123	if test $$1 = yes; then
1124		AC_DEFINE(HAVE_AAAA)
1125	fi
1126])
1127
1128dnl
1129dnl check for struct res_state_ext
1130AC_DEFUN(AC_STRUCT_RES_STATE_EXT, [
1131	AC_MSG_CHECKING(for res_state_ext)
1132	AC_CACHE_VAL($1,
1133	AC_TRY_COMPILE([
1134#		include <sys/types.h>
1135#		include <netinet/in.h>
1136#		include <netinet6/in6.h>
1137#		include <resolv.h>],
1138		[struct __res_state_ext e],
1139		$1=yes,
1140		$1=no))
1141	AC_MSG_RESULT($$1)
1142	if test $$1 = yes; then
1143		AC_DEFINE(HAVE_RES_STATE_EXT)
1144	fi
1145])
1146
1147dnl
1148dnl check for struct res_state_ext
1149AC_DEFUN(AC_STRUCT_RES_STATE, [
1150	AC_MSG_CHECKING(for nsort in res_state)
1151	AC_CACHE_VAL($1,
1152	AC_TRY_COMPILE([
1153#		include <sys/types.h>
1154#		include <netinet/in.h>
1155#		include <netinet6/in6.h>
1156#		include <resolv.h>],
1157		[struct __res_state e; e.nsort = 0],
1158		$1=yes,
1159		$1=no))
1160	AC_MSG_RESULT($$1)
1161	if test $$1 = yes; then
1162		AC_DEFINE(HAVE_NEW_RES_STATE)
1163	fi
1164])
1165
1166dnl
1167dnl check for h_errno
1168AC_DEFUN(AC_VAR_H_ERRNO, [
1169	AC_MSG_CHECKING(for h_errno)
1170	AC_CACHE_VAL(ac_cv_var_h_errno,
1171	AC_TRY_COMPILE([
1172#		include <sys/types.h>
1173#		include <netdb.h>],
1174		[int foo = h_errno;],
1175		ac_cv_var_h_errno=yes,
1176		ac_cv_var_h_errno=no))
1177	AC_MSG_RESULT($ac_cv_var_h_errno)
1178	if test "$ac_cv_var_h_errno" = "yes"; then
1179		AC_DEFINE(HAVE_H_ERRNO)
1180	fi
1181])
1182
1183dnl
1184dnl Test for __attribute__
1185dnl
1186
1187AC_DEFUN(AC_C___ATTRIBUTE__, [
1188AC_MSG_CHECKING(for __attribute__)
1189AC_CACHE_VAL(ac_cv___attribute__, [
1190AC_COMPILE_IFELSE(
1191  AC_LANG_SOURCE([[
1192#include <stdlib.h>
1193
1194static void foo(void) __attribute__ ((noreturn));
1195
1196static void
1197foo(void)
1198{
1199  exit(1);
1200}
1201
1202int
1203main(int argc, char **argv)
1204{
1205  foo();
1206}
1207  ]]),
1208ac_cv___attribute__=yes,
1209ac_cv___attribute__=no)])
1210if test "$ac_cv___attribute__" = "yes"; then
1211  AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
1212  V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""
1213else
1214  V_DEFS="$V_DEFS -D_U_=\"\""
1215fi
1216AC_MSG_RESULT($ac_cv___attribute__)
1217])
1218
1219
1220dnl
1221dnl Test whether __attribute__((format)) can be applied to function
1222dnl pointers
1223dnl
1224
1225AC_DEFUN(AC_C___ATTRIBUTE___FORMAT_FUNCTION_POINTER, [
1226AC_MSG_CHECKING([whether __attribute__((format)) can be applied to function pointers])
1227AC_CACHE_VAL(ac_cv___attribute___format_function_pointer, [
1228AC_COMPILE_IFELSE(
1229  AC_LANG_SOURCE([[
1230#include <stdlib.h>
1231
1232extern int (*foo)(const char *fmt, ...)
1233		  __attribute__ ((format (printf, 1, 2)));
1234
1235int
1236main(int argc, char **argv)
1237{
1238  (*foo)("%s", "test");
1239}
1240  ]]),
1241ac_cv___attribute___format_function_pointer=yes,
1242ac_cv___attribute___format_function_pointer=no)])
1243if test "$ac_cv___attribute___format_function_pointer" = "yes"; then
1244  AC_DEFINE(__ATTRIBUTE___FORMAT_OK_FOR_FUNCTION_POINTERS, 1,
1245    [define if your compiler allows __attribute__((format)) to be applied to function pointers])
1246fi
1247AC_MSG_RESULT($ac_cv___attribute___format_function_pointer)
1248])
1249
1250AC_DEFUN(AC_LBL_SSLEAY,
1251    [
1252	#
1253	# Find the last component of $libdir; it's not necessarily
1254	# "lib" - it might be "lib64" on, for example, x86-64
1255	# Linux systems.
1256	#
1257	# We assume the directory in which we're looking for
1258	# libcrypto has a subdirectory with that as its name.
1259	#
1260	tmplib=`echo "$libdir" | sed 's,.*/,,'`
1261
1262	#
1263	# XXX - is there a better way to check if a given library is
1264	# in a given directory than checking each of the possible
1265	# shared library suffixes?
1266	#
1267	# Are there any other suffixes we need to look for?  Do we
1268	# have to worry about ".so.{version}"?
1269	#
1270	# Or should we just look for "libcrypto.*"?
1271	#
1272	if test -d "$1/$tmplib" -a \( -f "$1/$tmplib/libcrypto.a" -o \
1273		          	    -f "$1/$tmplib/libcrypto.so" -o \
1274		          	    -f "$1/$tmplib/libcrypto.sl" -o \
1275			  	    -f "$1/$tmplib/libcrypto.dylib" \); then
1276		ac_cv_ssleay_path="$1"
1277	fi
1278
1279	#
1280	# Make sure we have the headers as well.
1281	#
1282	if test -d "$1/include/openssl" -a -f "$1/include/openssl/des.h"; then
1283		incdir="-I$1/include"
1284	fi
1285])
1286