aclocal.m4

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