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