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