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