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