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