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