• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1dnl @(#) $Header: /tcpdump/master/libpcap/aclocal.m4,v 1.85.2.1 2005/04/21 03:42:09 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 Determine which compiler we're using (cc or gcc)
27dnl If using gcc, determine the version number
28dnl If using cc, require that it support ansi prototypes
29dnl If using gcc, use -O2 (otherwise use -O)
30dnl If using cc, explicitly specify /usr/local/include
31dnl
32dnl usage:
33dnl
34dnl	AC_LBL_C_INIT(copt, incls)
35dnl
36dnl results:
37dnl
38dnl	$1 (copt set)
39dnl	$2 (incls set)
40dnl	CC
41dnl	LDFLAGS
42dnl	ac_cv_lbl_gcc_vers
43dnl	LBL_CFLAGS
44dnl
45AC_DEFUN(AC_LBL_C_INIT,
46    [AC_PREREQ(2.12)
47    AC_BEFORE([$0], [AC_PROG_CC])
48    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
49    AC_BEFORE([$0], [AC_LBL_DEVEL])
50    AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
51    $1="-O"
52    $2=""
53    if test "${srcdir}" != "." ; then
54	    $2="-I\$(srcdir)"
55    fi
56    if test "${CFLAGS+set}" = set; then
57	    LBL_CFLAGS="$CFLAGS"
58    fi
59    if test -z "$CC" ; then
60	    case "$target_os" in
61
62	    bsdi*)
63		    AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
64		    if test $SHLICC2 = yes ; then
65			    CC=shlicc2
66			    export CC
67		    fi
68		    ;;
69	    esac
70    fi
71    if test -z "$CC" -a "$with_gcc" = no ; then
72	    CC=cc
73	    export CC
74    fi
75    AC_PROG_CC
76    if test "$GCC" = yes ; then
77	    if test "$SHLICC2" = yes ; then
78		    ac_cv_lbl_gcc_vers=2
79		    $1="-O2"
80	    else
81		    AC_MSG_CHECKING(gcc version)
82		    AC_CACHE_VAL(ac_cv_lbl_gcc_vers,
83			ac_cv_lbl_gcc_vers=`$CC -v 2>&1 | \
84			    sed -e '/^gcc version /!d' \
85				-e 's/^gcc version //' \
86				-e 's/ .*//' -e 's/^[[[^0-9]]]*//' \
87				-e 's/\..*//'`)
88		    AC_MSG_RESULT($ac_cv_lbl_gcc_vers)
89		    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
90			    $1="-O2"
91		    fi
92	    fi
93    else
94	    AC_MSG_CHECKING(that $CC handles ansi prototypes)
95	    AC_CACHE_VAL(ac_cv_lbl_cc_ansi_prototypes,
96		AC_TRY_COMPILE(
97		    [#include <sys/types.h>],
98		    [int frob(int, char *)],
99		    ac_cv_lbl_cc_ansi_prototypes=yes,
100		    ac_cv_lbl_cc_ansi_prototypes=no))
101	    AC_MSG_RESULT($ac_cv_lbl_cc_ansi_prototypes)
102	    if test $ac_cv_lbl_cc_ansi_prototypes = no ; then
103		    case "$target_os" in
104
105		    hpux*)
106			    AC_MSG_CHECKING(for HP-UX ansi compiler ($CC -Aa -D_HPUX_SOURCE))
107			    savedcflags="$CFLAGS"
108			    CFLAGS="-Aa -D_HPUX_SOURCE $CFLAGS"
109			    AC_CACHE_VAL(ac_cv_lbl_cc_hpux_cc_aa,
110				AC_TRY_COMPILE(
111				    [#include <sys/types.h>],
112				    [int frob(int, char *)],
113				    ac_cv_lbl_cc_hpux_cc_aa=yes,
114				    ac_cv_lbl_cc_hpux_cc_aa=no))
115			    AC_MSG_RESULT($ac_cv_lbl_cc_hpux_cc_aa)
116			    if test $ac_cv_lbl_cc_hpux_cc_aa = no ; then
117				    AC_MSG_ERROR(see the INSTALL doc for more info)
118			    fi
119			    CFLAGS="$savedcflags"
120			    V_CCOPT="-Aa $V_CCOPT"
121			    AC_DEFINE(_HPUX_SOURCE,1,[needed on HP-UX])
122			    ;;
123
124		    *)
125			    AC_MSG_ERROR(see the INSTALL doc for more info)
126			    ;;
127		    esac
128	    fi
129	    $2="$$2 -I/usr/local/include"
130	    LDFLAGS="$LDFLAGS -L/usr/local/lib"
131
132	    case "$target_os" in
133
134	    irix*)
135		    V_CCOPT="$V_CCOPT -xansi -signed -g3"
136		    ;;
137
138	    osf*)
139		    V_CCOPT="$V_CCOPT -std1 -g3"
140		    ;;
141
142	    ultrix*)
143		    AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
144		    AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
145			AC_TRY_COMPILE(
146			    [#include <sys/types.h>],
147			    [struct a { int b; };
148			    void c(const struct a *)],
149			    ac_cv_lbl_cc_const_proto=yes,
150			    ac_cv_lbl_cc_const_proto=no))
151		    AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
152		    if test $ac_cv_lbl_cc_const_proto = no ; then
153			    AC_DEFINE(const,)
154		    fi
155		    ;;
156	    esac
157    fi
158])
159
160#
161# Try compiling a sample of the type of code that appears in
162# gencode.c with "inline", "__inline__", and "__inline".
163#
164# Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
165# as it just tests whether a function returning "int" can be inlined;
166# at least some versions of HP's C compiler can inline that, but can't
167# inline a function that returns a struct pointer.
168#
169# Make sure we use the V_CCOPT flags, because some of those might
170# disable inlining.
171#
172AC_DEFUN(AC_LBL_C_INLINE,
173    [AC_MSG_CHECKING(for inline)
174    save_CFLAGS="$CFLAGS"
175    CFLAGS="$V_CCOPT"
176    AC_CACHE_VAL(ac_cv_lbl_inline, [
177	ac_cv_lbl_inline=""
178	ac_lbl_cc_inline=no
179	for ac_lbl_inline in inline __inline__ __inline
180	do
181	    AC_TRY_COMPILE(
182		[#define inline $ac_lbl_inline
183		static inline struct iltest *foo(void);
184		struct iltest {
185		    int iltest1;
186		    int iltest2;
187		};
188
189		static inline struct iltest *
190		foo()
191		{
192		    static struct iltest xxx;
193
194		    return &xxx;
195		}],,ac_lbl_cc_inline=yes,)
196	    if test "$ac_lbl_cc_inline" = yes ; then
197		break;
198	    fi
199	done
200	if test "$ac_lbl_cc_inline" = yes ; then
201	    ac_cv_lbl_inline=$ac_lbl_inline
202	fi])
203    CFLAGS="$save_CFLAGS"
204    if test ! -z "$ac_cv_lbl_inline" ; then
205	AC_MSG_RESULT($ac_cv_lbl_inline)
206    else
207	AC_MSG_RESULT(no)
208    fi
209    AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
210
211dnl
212dnl Use pfopen.c if available and pfopen() not in standard libraries
213dnl Require libpcap
214dnl Look for libpcap in ..
215dnl Use the installed libpcap if there is no local version
216dnl
217dnl usage:
218dnl
219dnl	AC_LBL_LIBPCAP(pcapdep, incls)
220dnl
221dnl results:
222dnl
223dnl	$1 (pcapdep set)
224dnl	$2 (incls appended)
225dnl	LIBS
226dnl	LBL_LIBS
227dnl
228AC_DEFUN(AC_LBL_LIBPCAP,
229    [AC_REQUIRE([AC_LBL_LIBRARY_NET])
230    dnl
231    dnl save a copy before locating libpcap.a
232    dnl
233    LBL_LIBS="$LIBS"
234    pfopen=/usr/examples/packetfilter/pfopen.c
235    if test -f $pfopen ; then
236	    AC_CHECK_FUNCS(pfopen)
237	    if test $ac_cv_func_pfopen = "no" ; then
238		    AC_MSG_RESULT(Using $pfopen)
239		    LIBS="$LIBS $pfopen"
240	    fi
241    fi
242    AC_MSG_CHECKING(for local pcap library)
243    libpcap=FAIL
244    lastdir=FAIL
245    places=`ls .. | sed -e 's,/$,,' -e 's,^,../,' | \
246	egrep '/libpcap-[[0-9]]*\.[[0-9]]*(\.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
247    for dir in $places ../libpcap libpcap ; do
248	    basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//'`
249	    if test $lastdir = $basedir ; then
250		    dnl skip alphas when an actual release is present
251		    continue;
252	    fi
253	    lastdir=$dir
254	    if test -r $dir/pcap.c ; then
255		    libpcap=$dir/libpcap.a
256		    d=$dir
257		    dnl continue and select the last one that exists
258	    fi
259    done
260    if test $libpcap = FAIL ; then
261	    AC_MSG_RESULT(not found)
262	    AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
263	    if test $libpcap = FAIL ; then
264		    AC_MSG_ERROR(see the INSTALL doc for more info)
265	    fi
266    else
267	    $1=$libpcap
268	    $2="-I$d $$2"
269	    AC_MSG_RESULT($libpcap)
270    fi
271    LIBS="$libpcap $LIBS"
272    case "$target_os" in
273
274    aix*)
275	    pseexe="/lib/pse.exp"
276	    AC_MSG_CHECKING(for $pseexe)
277	    if test -f $pseexe ; then
278		    AC_MSG_RESULT(yes)
279		    LIBS="$LIBS -I:$pseexe"
280	    fi
281	    ;;
282    esac])
283
284dnl
285dnl Define RETSIGTYPE and RETSIGVAL
286dnl
287dnl usage:
288dnl
289dnl	AC_LBL_TYPE_SIGNAL
290dnl
291dnl results:
292dnl
293dnl	RETSIGTYPE (defined)
294dnl	RETSIGVAL (defined)
295dnl
296AC_DEFUN(AC_LBL_TYPE_SIGNAL,
297    [AC_BEFORE([$0], [AC_LBL_LIBPCAP])
298    AC_TYPE_SIGNAL
299    if test "$ac_cv_type_signal" = void ; then
300	    AC_DEFINE(RETSIGVAL,[],[return value of signal handlers])
301    else
302	    AC_DEFINE(RETSIGVAL,(0),[return value of signal handlers])
303    fi
304    case "$target_os" in
305
306    irix*)
307	    AC_DEFINE(_BSD_SIGNALS,1,[get BSD semantics on Irix])
308	    ;;
309
310    *)
311	    dnl prefer sigset() to sigaction()
312	    AC_CHECK_FUNCS(sigset)
313	    if test $ac_cv_func_sigset = no ; then
314		    AC_CHECK_FUNCS(sigaction)
315	    fi
316	    ;;
317    esac])
318
319dnl
320dnl If using gcc, make sure we have ANSI ioctl definitions
321dnl
322dnl usage:
323dnl
324dnl	AC_LBL_FIXINCLUDES
325dnl
326AC_DEFUN(AC_LBL_FIXINCLUDES,
327    [if test "$GCC" = yes ; then
328	    AC_MSG_CHECKING(for ANSI ioctl definitions)
329	    AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
330		AC_TRY_COMPILE(
331		    [/*
332		     * This generates a "duplicate case value" when fixincludes
333		     * has not be run.
334		     */
335#		include <sys/types.h>
336#		include <sys/time.h>
337#		include <sys/ioctl.h>
338#		ifdef HAVE_SYS_IOCCOM_H
339#		include <sys/ioccom.h>
340#		endif],
341		    [switch (0) {
342		    case _IO('A', 1):;
343		    case _IO('B', 1):;
344		    }],
345		    ac_cv_lbl_gcc_fixincludes=yes,
346		    ac_cv_lbl_gcc_fixincludes=no))
347	    AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
348	    if test $ac_cv_lbl_gcc_fixincludes = no ; then
349		    # Don't cache failure
350		    unset ac_cv_lbl_gcc_fixincludes
351		    AC_MSG_ERROR(see the INSTALL for more info)
352	    fi
353    fi])
354
355dnl
356dnl Check for flex, default to lex
357dnl Require flex 2.4 or higher
358dnl Check for bison, default to yacc
359dnl Default to lex/yacc if both flex and bison are not available
360dnl Define the yy prefix string if using flex and bison
361dnl
362dnl usage:
363dnl
364dnl	AC_LBL_LEX_AND_YACC(lex, yacc, yyprefix)
365dnl
366dnl results:
367dnl
368dnl	$1 (lex set)
369dnl	$2 (yacc appended)
370dnl	$3 (optional flex and bison -P prefix)
371dnl
372AC_DEFUN(AC_LBL_LEX_AND_YACC,
373    [AC_ARG_WITH(flex, [  --without-flex          don't use flex])
374    AC_ARG_WITH(bison, [  --without-bison         don't use bison])
375    if test "$with_flex" = no ; then
376	    $1=lex
377    else
378	    AC_CHECK_PROGS($1, flex, lex)
379    fi
380    if test "$$1" = flex ; then
381	    # The -V flag was added in 2.4
382	    AC_MSG_CHECKING(for flex 2.4 or higher)
383	    AC_CACHE_VAL(ac_cv_lbl_flex_v24,
384		if flex -V >/dev/null 2>&1; then
385			ac_cv_lbl_flex_v24=yes
386		else
387			ac_cv_lbl_flex_v24=no
388		fi)
389	    AC_MSG_RESULT($ac_cv_lbl_flex_v24)
390	    if test $ac_cv_lbl_flex_v24 = no ; then
391		    s="2.4 or higher required"
392		    AC_MSG_WARN(ignoring obsolete flex executable ($s))
393		    $1=lex
394	    fi
395    fi
396    if test "$with_bison" = no ; then
397	    $2=yacc
398    else
399	    AC_CHECK_PROGS($2, bison, yacc)
400    fi
401    if test "$$2" = bison ; then
402	    $2="$$2 -y"
403    fi
404    if test "$$1" != lex -a "$$2" = yacc -o "$$1" = lex -a "$$2" != yacc ; then
405	    AC_MSG_WARN(don't have both flex and bison; reverting to lex/yacc)
406	    $1=lex
407	    $2=yacc
408    fi
409    if test "$$1" = flex -a -n "$3" ; then
410	    $1="$$1 -P$3"
411	    $2="$$2 -p $3"
412    fi])
413
414dnl
415dnl Checks to see if union wait is used with WEXITSTATUS()
416dnl
417dnl usage:
418dnl
419dnl	AC_LBL_UNION_WAIT
420dnl
421dnl results:
422dnl
423dnl	DECLWAITSTATUS (defined)
424dnl
425AC_DEFUN(AC_LBL_UNION_WAIT,
426    [AC_MSG_CHECKING(if union wait is used)
427    AC_CACHE_VAL(ac_cv_lbl_union_wait,
428	AC_TRY_COMPILE([
429#	include <sys/types.h>
430#	include <sys/wait.h>],
431	    [int status;
432	    u_int i = WEXITSTATUS(status);
433	    u_int j = waitpid(0, &status, 0);],
434	    ac_cv_lbl_union_wait=no,
435	    ac_cv_lbl_union_wait=yes))
436    AC_MSG_RESULT($ac_cv_lbl_union_wait)
437    if test $ac_cv_lbl_union_wait = yes ; then
438	    AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])
439    else
440	    AC_DEFINE(DECLWAITSTATUS,int,[type for wait])
441    fi])
442
443dnl
444dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
445dnl
446dnl usage:
447dnl
448dnl	AC_LBL_SOCKADDR_SA_LEN
449dnl
450dnl results:
451dnl
452dnl	HAVE_SOCKADDR_SA_LEN (defined)
453dnl
454AC_DEFUN(AC_LBL_SOCKADDR_SA_LEN,
455    [AC_MSG_CHECKING(if sockaddr struct has sa_len member)
456    AC_CACHE_VAL(ac_cv_lbl_sockaddr_has_sa_len,
457	AC_TRY_COMPILE([
458#	include <sys/types.h>
459#	include <sys/socket.h>],
460	[u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
461	ac_cv_lbl_sockaddr_has_sa_len=yes,
462	ac_cv_lbl_sockaddr_has_sa_len=no))
463    AC_MSG_RESULT($ac_cv_lbl_sockaddr_has_sa_len)
464    if test $ac_cv_lbl_sockaddr_has_sa_len = yes ; then
465	    AC_DEFINE(HAVE_SOCKADDR_SA_LEN,1,[if struct sockaddr has sa_len])
466    fi])
467
468dnl
469dnl Checks to see if there's a sockaddr_storage structure
470dnl
471dnl usage:
472dnl
473dnl	AC_LBL_SOCKADDR_STORAGE
474dnl
475dnl results:
476dnl
477dnl	HAVE_SOCKADDR_STORAGE (defined)
478dnl
479AC_DEFUN(AC_LBL_SOCKADDR_STORAGE,
480    [AC_MSG_CHECKING(if sockaddr_storage struct exists)
481    AC_CACHE_VAL(ac_cv_lbl_has_sockaddr_storage,
482	AC_TRY_COMPILE([
483#	include <sys/types.h>
484#	include <sys/socket.h>],
485	[u_int i = sizeof (struct sockaddr_storage)],
486	ac_cv_lbl_has_sockaddr_storage=yes,
487	ac_cv_lbl_has_sockaddr_storage=no))
488    AC_MSG_RESULT($ac_cv_lbl_has_sockaddr_storage)
489    if test $ac_cv_lbl_has_sockaddr_storage = yes ; then
490	    AC_DEFINE(HAVE_SOCKADDR_STORAGE,1,[if struct sockaddr_storage exists])
491    fi])
492
493dnl
494dnl Checks to see if the dl_hp_ppa_info_t struct has the HP-UX 11.00
495dnl dl_module_id_1 member
496dnl
497dnl usage:
498dnl
499dnl	AC_LBL_HP_PPA_INFO_T_DL_MODULE_ID_1
500dnl
501dnl results:
502dnl
503dnl	HAVE_HP_PPA_INFO_T_DL_MODULE_ID_1 (defined)
504dnl
505dnl NOTE: any compile failure means we conclude that it doesn't have
506dnl that member, so if we don't have DLPI, don't have a <sys/dlpi_ext.h>
507dnl header, or have one that doesn't declare a dl_hp_ppa_info_t type,
508dnl we conclude it doesn't have that member (which is OK, as either we
509dnl won't be using code that would use that member, or we wouldn't
510dnl compile in any case).
511dnl
512AC_DEFUN(AC_LBL_HP_PPA_INFO_T_DL_MODULE_ID_1,
513    [AC_MSG_CHECKING(if dl_hp_ppa_info_t struct has dl_module_id_1 member)
514    AC_CACHE_VAL(ac_cv_lbl_dl_hp_ppa_info_t_has_dl_module_id_1,
515	AC_TRY_COMPILE([
516#	include <sys/types.h>
517#	include <sys/dlpi.h>
518#	include <sys/dlpi_ext.h>],
519	[u_int i = sizeof(((dl_hp_ppa_info_t *)0)->dl_module_id_1)],
520	ac_cv_lbl_dl_hp_ppa_info_t_has_dl_module_id_1=yes,
521	ac_cv_lbl_dl_hp_ppa_info_t_has_dl_module_id_1=no))
522    AC_MSG_RESULT($ac_cv_lbl_dl_hp_ppa_info_t_has_dl_module_id_1)
523    if test $ac_cv_lbl_dl_hp_ppa_info_t_has_dl_module_id_1 = yes ; then
524	    AC_DEFINE(HAVE_HP_PPA_INFO_T_DL_MODULE_ID_1,1,[if ppa_info_t_dl_module_id exists])
525    fi])
526
527dnl
528dnl Checks to see if -R is used
529dnl
530dnl usage:
531dnl
532dnl	AC_LBL_HAVE_RUN_PATH
533dnl
534dnl results:
535dnl
536dnl	ac_cv_lbl_have_run_path (yes or no)
537dnl
538AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
539    [AC_MSG_CHECKING(for ${CC-cc} -R)
540    AC_CACHE_VAL(ac_cv_lbl_have_run_path,
541	[echo 'main(){}' > conftest.c
542	${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
543	if test ! -s conftest.out ; then
544		ac_cv_lbl_have_run_path=yes
545	else
546		ac_cv_lbl_have_run_path=no
547	fi
548	rm -f conftest*])
549    AC_MSG_RESULT($ac_cv_lbl_have_run_path)
550    ])
551
552dnl
553dnl Due to the stupid way it's implemented, AC_CHECK_TYPE is nearly useless.
554dnl
555dnl usage:
556dnl
557dnl	AC_LBL_CHECK_TYPE
558dnl
559dnl results:
560dnl
561dnl	int32_t (defined)
562dnl	u_int32_t (defined)
563dnl
564AC_DEFUN(AC_LBL_CHECK_TYPE,
565    [AC_MSG_CHECKING(for $1 using $CC)
566    AC_CACHE_VAL(ac_cv_lbl_have_$1,
567	AC_TRY_COMPILE([
568#	include "confdefs.h"
569#	include <sys/types.h>
570#	if STDC_HEADERS
571#	include <stdlib.h>
572#	include <stddef.h>
573#	endif],
574	[$1 i],
575	ac_cv_lbl_have_$1=yes,
576	ac_cv_lbl_have_$1=no))
577    AC_MSG_RESULT($ac_cv_lbl_have_$1)
578    if test $ac_cv_lbl_have_$1 = no ; then
579	    AC_DEFINE($1, $2, [if we have $1])
580    fi])
581
582dnl
583dnl Checks to see if unaligned memory accesses fail
584dnl
585dnl usage:
586dnl
587dnl	AC_LBL_UNALIGNED_ACCESS
588dnl
589dnl results:
590dnl
591dnl	LBL_ALIGN (DEFINED)
592dnl
593AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,
594    [AC_MSG_CHECKING(if unaligned accesses fail)
595    AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,
596	[case "$host_cpu" in
597
598	#
599	# These are CPU types where:
600	#
601	#	the CPU faults on an unaligned access, but at least some
602	#	OSes that support that CPU catch the fault and simulate
603	#	the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -
604	#	the simulation is slow, so we don't want to use it;
605	#
606	#	the CPU, I infer (from the old
607	#
608	# XXX: should also check that they don't do weird things (like on arm)
609	#
610	#	comment) doesn't fault on unaligned accesses, but doesn't
611	#	do a normal unaligned fetch, either (e.g., presumably, ARM);
612	#
613	#	for whatever reason, the test program doesn't work
614	#	(this has been claimed to be the case for several of those
615	#	CPUs - I don't know what the problem is; the problem
616	#	was reported as "the test program dumps core" for SuperH,
617	#	but that's what the test program is *supposed* to do -
618	#	it dumps core before it writes anything, so the test
619	#	for an empty output file should find an empty output
620	#	file and conclude that unaligned accesses don't work).
621	#
622	# This run-time test won't work if you're cross-compiling, so
623	# in order to support cross-compiling for a particular CPU,
624	# we have to wire in the list of CPU types anyway, as far as
625	# I know, so perhaps we should just have a set of CPUs on
626	# which we know it doesn't work, a set of CPUs on which we
627	# know it does work, and have the script just fail on other
628	# cpu types and update it when such a failure occurs.
629	#
630	alpha*|arm*|hp*|mips*|sh*|sparc*|ia64|nv1)
631		ac_cv_lbl_unaligned_fail=yes
632		;;
633
634	*)
635		cat >conftest.c <<EOF
636#		include <sys/types.h>
637#		include <sys/wait.h>
638#		include <stdio.h>
639		unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
640		main() {
641		unsigned int i;
642		pid_t pid;
643		int status;
644		/* avoid "core dumped" message */
645		pid = fork();
646		if (pid <  0)
647			exit(2);
648		if (pid > 0) {
649			/* parent */
650			pid = waitpid(pid, &status, 0);
651			if (pid < 0)
652				exit(3);
653			exit(!WIFEXITED(status));
654		}
655		/* child */
656		i = *(unsigned int *)&a[[1]];
657		printf("%d\n", i);
658		exit(0);
659		}
660EOF
661		${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
662		    conftest.c $LIBS >/dev/null 2>&1
663		if test ! -x conftest ; then
664			dnl failed to compile for some reason
665			ac_cv_lbl_unaligned_fail=yes
666		else
667			./conftest >conftest.out
668			if test ! -s conftest.out ; then
669				ac_cv_lbl_unaligned_fail=yes
670			else
671				ac_cv_lbl_unaligned_fail=no
672			fi
673		fi
674		rm -f conftest* core core.conftest
675		;;
676	esac])
677    AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)
678    if test $ac_cv_lbl_unaligned_fail = yes ; then
679	    AC_DEFINE(LBL_ALIGN,1,[if unaligned access fails])
680    fi])
681
682dnl
683dnl If using gcc and the file .devel exists:
684dnl	Compile with -g (if supported) and -Wall
685dnl	If using gcc 2, do extra prototype checking
686dnl	If an os prototype include exists, symlink os-proto.h to it
687dnl
688dnl usage:
689dnl
690dnl	AC_LBL_DEVEL(copt)
691dnl
692dnl results:
693dnl
694dnl	$1 (copt appended)
695dnl	HAVE_OS_PROTO_H (defined)
696dnl	os-proto.h (symlinked)
697dnl
698AC_DEFUN(AC_LBL_DEVEL,
699    [rm -f os-proto.h
700    if test "${LBL_CFLAGS+set}" = set; then
701	    $1="$$1 ${LBL_CFLAGS}"
702    fi
703    if test -f .devel ; then
704	    if test "$GCC" = yes ; then
705		    if test "${LBL_CFLAGS+set}" != set; then
706			    if test "$ac_cv_prog_cc_g" = yes ; then
707				    $1="-g $$1"
708			    fi
709			    $1="$$1 -Wall"
710			    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
711				    $1="$$1 -Wmissing-prototypes -Wstrict-prototypes"
712			    fi
713		    fi
714	    else
715		    case "$target_os" in
716
717		    irix6*)
718			    V_CCOPT="$V_CCOPT -n32"
719			    ;;
720
721		    *)
722			    ;;
723		    esac
724	    fi
725	    os=`echo $target_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
726	    name="lbl/os-$os.h"
727	    if test -f $name ; then
728		    ln -s $name os-proto.h
729		    AC_DEFINE(HAVE_OS_PROTO_H,1,[if there's an os_proto.h])
730	    else
731		    AC_MSG_WARN(can't find $name)
732	    fi
733    fi])
734
735dnl
736dnl Improved version of AC_CHECK_LIB
737dnl
738dnl Thanks to John Hawkinson (jhawk@mit.edu)
739dnl
740dnl usage:
741dnl
742dnl	AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
743dnl	    ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
744dnl
745dnl results:
746dnl
747dnl	LIBS
748dnl
749
750define(AC_LBL_CHECK_LIB,
751[AC_MSG_CHECKING([for $2 in -l$1])
752dnl Use a cache variable name containing both the library and function name,
753dnl because the test really is for library $1 defining function $2, not
754dnl just for library $1.  Separate tests with the same $1 and different $2's
755dnl may have different results.
756ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
757AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
758[ac_save_LIBS="$LIBS"
759LIBS="-l$1 $5 $LIBS"
760AC_TRY_LINK(dnl
761ifelse([$2], [main], , dnl Avoid conflicting decl of main.
762[/* Override any gcc2 internal prototype to avoid an error.  */
763]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
764extern "C"
765#endif
766])dnl
767[/* We use char because int might match the return type of a gcc2
768    builtin and then its argument prototype would still apply.  */
769char $2();
770]),
771	    [$2()],
772	    eval "ac_cv_lbl_lib_$ac_lib_var=yes",
773	    eval "ac_cv_lbl_lib_$ac_lib_var=no")
774LIBS="$ac_save_LIBS"
775])dnl
776if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
777  AC_MSG_RESULT(yes)
778  ifelse([$3], ,
779[changequote(, )dnl
780  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
781    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
782changequote([, ])dnl
783  AC_DEFINE_UNQUOTED($ac_tr_lib)
784  LIBS="-l$1 $LIBS"
785], [$3])
786else
787  AC_MSG_RESULT(no)
788ifelse([$4], , , [$4
789])dnl
790fi
791])
792
793dnl
794dnl AC_LBL_LIBRARY_NET
795dnl
796dnl This test is for network applications that need socket() and
797dnl gethostbyname() -ish functions.  Under Solaris, those applications
798dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
799dnl with "-lnsl" but should *not* link with "-lsocket" because
800dnl libsocket.a breaks a number of things (for instance:
801dnl gethostbyname() under IRIX 5.2, and snoop sockets under most
802dnl versions of IRIX).
803dnl
804dnl Unfortunately, many application developers are not aware of this,
805dnl and mistakenly write tests that cause -lsocket to be used under
806dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
807dnl under operating systems where neither are necessary (or useful),
808dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
809dnl
810dnl This test exists so that every application developer does not test
811dnl this in a different, and subtly broken fashion.
812
813dnl It has been argued that this test should be broken up into two
814dnl seperate tests, one for the resolver libraries, and one for the
815dnl libraries necessary for using Sockets API. Unfortunately, the two
816dnl are carefully intertwined and allowing the autoconf user to use
817dnl them independantly potentially results in unfortunate ordering
818dnl dependancies -- as such, such component macros would have to
819dnl carefully use indirection and be aware if the other components were
820dnl executed. Since other autoconf macros do not go to this trouble,
821dnl and almost no applications use sockets without the resolver, this
822dnl complexity has not been implemented.
823dnl
824dnl The check for libresolv is in case you are attempting to link
825dnl statically and happen to have a libresolv.a lying around (and no
826dnl libnsl.a).
827dnl
828AC_DEFUN(AC_LBL_LIBRARY_NET, [
829    # Most operating systems have gethostbyname() in the default searched
830    # libraries (i.e. libc):
831    # Some OSes (eg. Solaris) place it in libnsl
832    # Some strange OSes (SINIX) have it in libsocket:
833    AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)
834    # Unfortunately libsocket sometimes depends on libnsl and
835    # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
836    if test "$ac_cv_search_gethostbyname" = "no"
837    then
838	AC_CHECK_LIB(socket, gethostbyname,
839                     LIBS="-lsocket -lnsl $LIBS", , -lnsl)
840    fi
841    AC_SEARCH_LIBS(socket, socket, ,
842	AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
843    # DLPI needs putmsg under HPUX so test for -lstr while we're at it
844    AC_SEARCH_LIBS(putmsg, str)
845    ])
846
847dnl
848dnl Test for __attribute__
849dnl
850
851AC_DEFUN(AC_C___ATTRIBUTE__, [
852AC_MSG_CHECKING(for __attribute__)
853AC_CACHE_VAL(ac_cv___attribute__, [
854AC_COMPILE_IFELSE(
855  AC_LANG_SOURCE([[
856#include <stdlib.h>
857
858static void foo(void) __attribute__ ((noreturn));
859
860static void
861foo(void)
862{
863  exit(1);
864}
865
866int
867main(int argc, char **argv)
868{
869  foo();
870}
871  ]]),
872ac_cv___attribute__=yes,
873ac_cv___attribute__=no)])
874if test "$ac_cv___attribute__" = "yes"; then
875  AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
876  V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""
877else
878  V_DEFS="$V_DEFS -D_U_=\"\""
879fi
880AC_MSG_RESULT($ac_cv___attribute__)
881])
882
883dnl
884dnl Checks to see if tpacket_stats is defined in linux/if_packet.h
885dnl If so then pcap-linux.c can use this to report proper statistics.
886dnl
887dnl -Scott Barron
888dnl
889AC_DEFUN(AC_LBL_TPACKET_STATS,
890   [AC_MSG_CHECKING(if if_packet.h has tpacket_stats defined)
891   AC_CACHE_VAL(ac_cv_lbl_tpacket_stats,
892   AC_TRY_COMPILE([
893#  include <linux/if_packet.h>],
894   [struct tpacket_stats stats],
895   ac_cv_lbl_tpacket_stats=yes,
896   ac_cv_lbl_tpacket_stats=no))
897   AC_MSG_RESULT($ac_cv_lbl_tpacket_stats)
898   if test $ac_cv_lbl_tpacket_stats = yes; then
899       AC_DEFINE(HAVE_TPACKET_STATS,1,[if if_packet.h has tpacket_stats defined])
900   fi])
901