The Tcpdump Group git mirrors - tcpdump/blob - 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 directories under ..; those are local versions.
 455 dnl Look for an installed libpcap if there is no local version or if
 456 dnl the user said not to look for a local version.
 457 dnl
 458 dnl usage:
 459 dnl
 460 dnl     AC_LBL_LIBPCAP(pcapdep, incls)
 461 dnl
 462 dnl results:
 463 dnl
 464 dnl     $1 (pcapdep set)
 465 dnl     $2 (incls appended)
 466 dnl     LIBS
 467 dnl     LBL_LIBS
 468 dnl
 469 AC_DEFUN(AC_LBL_LIBPCAP,
 470     [AC_REQUIRE([AC_LBL_LIBRARY_NET])
 471     dnl
 472     dnl save a copy before locating libpcap.a
 473     dnl
 474     LBL_LIBS="$LIBS"
 475     pfopen=/usr/examples/packetfilter/pfopen.c
 476     if test -f $pfopen ; then
 477         AC_CHECK_FUNCS(pfopen)
 478         if test $ac_cv_func_pfopen = "no" ; then
 479             AC_MSG_RESULT(Using $pfopen)
 480             LIBS="$LIBS $pfopen"
 481         fi
 482     fi
 483     libpcap=FAIL
 484     AC_ARG_WITH([system-libpcap],
 485         [AS_HELP_STRING([--with-system-libpcap], [don't use local pcap library])],
 486         [
 487             #
 488             # Don't look for a local libpcap.
 489             #
 490             using_local_libpcap=no
 491         ],
 492         [
 493             #
 494             # Look for a local pcap library.
 495             #
 496             AC_MSG_CHECKING(for local pcap library)
 497             lastdir=FAIL
 498             places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 499                 egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT)?$'`
 500             places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 501                 egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT)?$'`
 502             for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 503                 basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//' | \
 504                     sed -e 's/-PRE-GIT$//' `
 505                 if test $lastdir = $basedir ; then
 506                     dnl skip alphas when an actual release is present
 507                     continue;
 508                 fi
 509                 lastdir=$dir
 510                 if test -r $dir/libpcap.a ; then
 511                     libpcap=$dir/libpcap.a
 512                     local_pcap_dir=$dir
 513                     dnl continue and select the last one that exists
 514                 fi
 515             done
 516             if test $libpcap = FAIL ; then
 517                 #
 518                 # We didn't find a local libpcap.
 519                 #
 520                 AC_MSG_RESULT(not found)
 521                 using_local_libpcap=no;
 522             else
 523                 #
 524                 # We found a local libpcap.
 525                 #
 526                 AC_MSG_RESULT($libpcap)
 527                 using_local_libpcap=yes
 528             fi
 529         ])
 530
 531     if test $using_local_libpcap = no ; then
 532         #
 533         # We didn't find a local libpcap.
 534         # Look for an installed pcap-config.
 535         #
 536         AC_PATH_TOOL(PCAP_CONFIG, pcap-config)
 537         if test -n "$PCAP_CONFIG" ; then
 538             #
 539             # Found - use it to get the include flags for
 540             # libpcap and the flags to link with libpcap.
 541             #
 542             # Please read section 11.6 "Shell Substitutions"
 543             # in the autoconf manual before doing anything
 544             # to this that involves quoting.  Especially note
 545             # the statement "There is just no portable way to use
 546             # double-quoted strings inside double-quoted back-quoted
 547             # expressions (pfew!)."
 548             #
 549             cflags=`"$PCAP_CONFIG" --cflags`
 550             $2="$cflags $$2"
 551             libpcap=`"$PCAP_CONFIG" --libs`
 552         else
 553             #
 554             # Not found; look for an installed pcap.
 555             #
 556             AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
 557             if test $libpcap = FAIL ; then
 558                 AC_MSG_ERROR(see the INSTALL doc for more info)
 559             fi
 560             dnl
 561             dnl Some versions of Red Hat Linux put "pcap.h" in
 562             dnl "/usr/include/pcap"; had the LBL folks done so,
 563             dnl that would have been a good idea, but for
 564             dnl the Red Hat folks to do so just breaks source
 565             dnl compatibility with other systems.
 566             dnl
 567             dnl We work around this by assuming that, as we didn't
 568             dnl find a local libpcap, libpcap is in /usr/lib or
 569             dnl /usr/local/lib and that the corresponding header
 570             dnl file is under one of those directories; if we don't
 571             dnl find it in either of those directories, we check to
 572             dnl see if it's in a "pcap" subdirectory of them and,
 573             dnl if so, add that subdirectory to the "-I" list.
 574             dnl
 575             dnl (We now also put pcap.h in /usr/include/pcap, but we
 576             dnl leave behind a /usr/include/pcap.h that includes it,
 577             dnl so you can still just include <pcap.h>.)
 578             dnl
 579             AC_MSG_CHECKING(for extraneous pcap header directories)
 580             if test \( ! -r /usr/local/include/pcap.h \) -a \
 581                     \( ! -r /usr/include/pcap.h \); then
 582                 if test -r /usr/local/include/pcap/pcap.h; then
 583                     d="/usr/local/include/pcap"
 584                 elif test -r /usr/include/pcap/pcap.h; then
 585                     d="/usr/include/pcap"
 586                 fi
 587             fi
 588             if test -z "$d" ; then
 589                 AC_MSG_RESULT(not found)
 590             else
 591                 $2="-I$d $$2"
 592                 AC_MSG_RESULT(found -- -I$d added)
 593             fi
 594         fi
 595     else
 596         #
 597         # We found a local libpcap.
 598         # Look for its pcap-config script.
 599         #
 600         AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $local_pcap_dir)
 601
 602         if test -n "$PCAP_CONFIG"; then
 603             #
 604             # We don't want its --cflags or --libs output, because
 605             # those presume it's installed.  For the C compiler flags,
 606             # we add the source directory for the local libpcap, so
 607             # we pick up its header files.
 608             #
 609             # We do, however, want its additional libraries, as required
 610             # when linking statically, because it makes calls to
 611             # routines in those libraries, so we'll need to link with
 612             # them, because we'll be linking statically with it.
 613             #
 614             $2="-I$local_pcap_dir $$2"
 615             additional_libs=`"$PCAP_CONFIG" --static --additional-libs`
 616             libpcap="$libpcap $additional_libs"
 617         else
 618             #
 619             # It doesn't have a pcap-config script.
 620             # Make sure it has a pcap.h file.
 621             #
 622             $1=$libpcap
 623             places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 624                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 625             places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 626                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 627             pcapH=FAIL
 628             if test -r $local_pcap_dir/pcap.h; then
 629                 pcapH=$local_pcap_dir
 630             else
 631                 for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 632                     if test -r $dir/pcap.h ; then
 633                         pcapH=$dir
 634                     fi
 635                 done
 636             fi
 637
 638             if test $pcapH = FAIL ; then
 639                 AC_MSG_ERROR(cannot find pcap.h: see INSTALL)
 640             fi
 641
 642             #
 643             # Force the compiler to look for header files in the
 644             # directory containing pcap.h.
 645             #
 646             $2="-I$pcapH $$2"
 647         fi
 648     fi
 649
 650     if test -z "$PCAP_CONFIG"; then
 651         #
 652         # We don't have pcap-config; find out any additional link flags
 653         # we need.  (If we have pcap-config, we assume it tells us what
 654         # we need.)
 655         #
 656         case "$host_os" in
 657
 658         aix*)
 659             #
 660             # If libpcap is DLPI-based, we have to use /lib/pse.exp if
 661             # present, as we use the STREAMS routines.
 662             #
 663             # (XXX - true only if we're linking with a static libpcap?)
 664             #
 665             pseexe="/lib/pse.exp"
 666             AC_MSG_CHECKING(for $pseexe)
 667             if test -f $pseexe ; then
 668                 AC_MSG_RESULT(yes)
 669                 LIBS="$LIBS -I:$pseexe"
 670             fi
 671
 672             #
 673             # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as
 674             # we use them to load the BPF module.
 675             #
 676             # (XXX - true only if we're linking with a static libpcap?)
 677             #
 678             LIBS="$LIBS -lodm -lcfg"
 679             ;;
 680
 681         solaris*)
 682             # libdlpi is needed for Solaris 11 and later.
 683             AC_CHECK_LIB(dlpi, dlpi_walk, LIBS="$LIBS -ldlpi" LDFLAGS="-L/lib $LDFLAGS", ,-L/lib)
 684             ;;
 685         esac
 686     fi
 687
 688     LIBS="$libpcap $LIBS"
 689
 690     dnl
 691     dnl Check for "pcap_loop()", to make sure we found a working
 692     dnl libpcap and have all the right other libraries with which
 693     dnl to link.  (Otherwise, the checks below will fail, not
 694     dnl because the routines are missing from the library, but
 695     dnl because we aren't linking properly with libpcap, and
 696     dnl that will cause confusing errors at build time.)
 697     dnl
 698     AC_CHECK_FUNC(pcap_loop,,
 699     [
 700         AC_MSG_ERROR(
 701 [This is a bug, please follow the guidelines in CONTRIBUTING and include the
 702 config.log file in your report.  If you have downloaded libpcap from
 703 tcpdump.org, and built it yourself, please also include the config.log
 704 file from the libpcap source directory, the Makefile from the libpcap
 705 source directory, and the output of the make process for libpcap, as
 706 this could be a problem with the libpcap that was built, and we will
 707 not be able to determine why this is happening, and thus will not be
 708 able to fix it, without that information, as we have not been able to
 709 reproduce this problem ourselves.])
 710     ])
 711 ])
 712
 713 dnl
 714 dnl If using gcc, make sure we have ANSI ioctl definitions
 715 dnl
 716 dnl usage:
 717 dnl
 718 dnl     AC_LBL_FIXINCLUDES
 719 dnl
 720 AC_DEFUN(AC_LBL_FIXINCLUDES,
 721     [if test "$GCC" = yes ; then
 722             AC_MSG_CHECKING(for ANSI ioctl definitions)
 723             AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
 724                 AC_TRY_COMPILE(
 725                     [/*
 726                      * This generates a "duplicate case value" when fixincludes
 727                      * has not be run.
 728                      */
 729 #               include <sys/types.h>
 730 #               include <sys/time.h>
 731 #               include <sys/ioctl.h>
 732 #               ifdef HAVE_SYS_IOCCOM_H
 733 #               include <sys/ioccom.h>
 734 #               endif],
 735                     [switch (0) {
 736                     case _IO('A', 1):;
 737                     case _IO('B', 1):;
 738                     }],
 739                     ac_cv_lbl_gcc_fixincludes=yes,
 740                     ac_cv_lbl_gcc_fixincludes=no))
 741             AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
 742             if test $ac_cv_lbl_gcc_fixincludes = no ; then
 743                     # Don't cache failure
 744                     unset ac_cv_lbl_gcc_fixincludes
 745                     AC_MSG_ERROR(see the INSTALL for more info)
 746             fi
 747     fi])
 748
 749 dnl
 750 dnl Checks to see if union wait is used with WEXITSTATUS()
 751 dnl
 752 dnl usage:
 753 dnl
 754 dnl     AC_LBL_UNION_WAIT
 755 dnl
 756 dnl results:
 757 dnl
 758 dnl     DECLWAITSTATUS (defined)
 759 dnl
 760 AC_DEFUN(AC_LBL_UNION_WAIT,
 761     [AC_MSG_CHECKING(if union wait is used)
 762     AC_CACHE_VAL(ac_cv_lbl_union_wait,
 763         AC_TRY_COMPILE([
 764 #       include <sys/types.h>
 765 #       include <sys/wait.h>],
 766             [int status;
 767             u_int i = WEXITSTATUS(status);
 768             u_int j = waitpid(0, &status, 0);],
 769             ac_cv_lbl_union_wait=no,
 770             ac_cv_lbl_union_wait=yes))
 771     AC_MSG_RESULT($ac_cv_lbl_union_wait)
 772     if test $ac_cv_lbl_union_wait = yes ; then
 773             AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])
 774     else
 775             AC_DEFINE(DECLWAITSTATUS,int,[type for wait])
 776     fi])
 777
 778 dnl
 779 dnl Checks to see if -R is used
 780 dnl
 781 dnl usage:
 782 dnl
 783 dnl     AC_LBL_HAVE_RUN_PATH
 784 dnl
 785 dnl results:
 786 dnl
 787 dnl     ac_cv_lbl_have_run_path (yes or no)
 788 dnl
 789 AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
 790     [AC_MSG_CHECKING(for ${CC-cc} -R)
 791     AC_CACHE_VAL(ac_cv_lbl_have_run_path,
 792         [echo 'main(){}' > conftest.c
 793         ${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
 794         if test ! -s conftest.out ; then
 795                 ac_cv_lbl_have_run_path=yes
 796         else
 797                 ac_cv_lbl_have_run_path=no
 798         fi
 799         rm -f -r conftest*])
 800     AC_MSG_RESULT($ac_cv_lbl_have_run_path)
 801     ])
 802
 803 dnl
 804 dnl Check whether a given format can be used to print 64-bit integers
 805 dnl
 806 AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,
 807   [
 808     AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])
 809     AC_RUN_IFELSE(
 810       [
 811         AC_LANG_SOURCE(
 812           [[
 813 #           ifdef HAVE_INTTYPES_H
 814             #include <inttypes.h>
 815 #           endif
 816             #include <stdio.h>
 817             #include <sys/types.h>
 818
 819             main()
 820             {
 821               uint64_t t = 1;
 822               char strbuf[16+1];
 823               sprintf(strbuf, "%016$1x", t << 32);
 824               if (strcmp(strbuf, "0000000100000000") == 0)
 825                 exit(0);
 826               else
 827                 exit(1);
 828             }
 829           ]])
 830       ],
 831       [
 832         AC_DEFINE(PRId64, "$1d", [define if the platform doesn't define PRId64])
 833         AC_DEFINE(PRIo64, "$1o", [define if the platform doesn't define PRIo64])
 834         AC_DEFINE(PRIx64, "$1x", [define if the platform doesn't define PRIu64])
 835         AC_DEFINE(PRIu64, "$1u", [define if the platform doesn't define PRIx64])
 836         AC_MSG_RESULT(yes)
 837       ],
 838       [
 839         AC_MSG_RESULT(no)
 840         $2
 841       ])
 842   ])
 843
 844 dnl
 845 dnl If the file .devel exists:
 846 dnl     Add some warning flags if the compiler supports them
 847 dnl     If an os prototype include exists, symlink os-proto.h to it
 848 dnl
 849 dnl usage:
 850 dnl
 851 dnl     AC_LBL_DEVEL(copt)
 852 dnl
 853 dnl results:
 854 dnl
 855 dnl     $1 (copt appended)
 856 dnl     HAVE_OS_PROTO_H (defined)
 857 dnl     os-proto.h (symlinked)
 858 dnl
 859 AC_DEFUN(AC_LBL_DEVEL,
 860     [rm -f os-proto.h
 861     if test "${LBL_CFLAGS+set}" = set; then
 862             $1="$$1 ${LBL_CFLAGS}"
 863     fi
 864     if test -f .devel ; then
 865             #
 866             # Skip all the warning option stuff on some compilers.
 867             #
 868             if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then
 869                     AC_LBL_CHECK_UNKNOWN_WARNING_OPTION_ERROR()
 870                     AC_LBL_CHECK_COMPILER_OPT($1, -Wall)
 871                     AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)
 872                     AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)
 873                     AC_LBL_CHECK_COMPILER_OPT($1, -Wwrite-strings)
 874                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith)
 875                     AC_LBL_CHECK_COMPILER_OPT($1, -Wcast-qual)
 876                     AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)
 877                     AC_LBL_CHECK_COMPILER_OPT($1, -Wdeclaration-after-statement)
 878                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpedantic)
 879                     AC_LBL_CHECK_COMPILER_OPT($1, -Wold-style-definition)
 880                     AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused)
 881                     AC_LBL_CHECK_COMPILER_OPT($1, -W)
 882                     AC_LBL_CHECK_COMPILER_OPT($1, -Wassign-enum)
 883             fi
 884             AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()
 885             #
 886             # We used to set -n32 for IRIX 6 when not using GCC (presumed
 887             # to mean that we're using MIPS C or MIPSpro C); it specified
 888             # the "new" faster 32-bit ABI, introduced in IRIX 6.2.  I'm
 889             # not sure why that would be something to do *only* with a
 890             # .devel file; why should the ABI for which we produce code
 891             # depend on .devel?
 892             #
 893             os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
 894             name="lbl/os-$os.h"
 895             if test -f $name ; then
 896                     ln -s $name os-proto.h
 897                     AC_DEFINE(HAVE_OS_PROTO_H, 1,
 898                         [if there's an os_proto.h for this platform, to use additional prototypes])
 899             else
 900                     AC_MSG_WARN(can't find $name)
 901             fi
 902     fi])
 903
 904 dnl
 905 dnl Improved version of AC_CHECK_LIB
 906 dnl
 907 dnl Thanks to John Hawkinson (jhawk@mit.edu)
 908 dnl
 909 dnl usage:
 910 dnl
 911 dnl     AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
 912 dnl         ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
 913 dnl
 914 dnl results:
 915 dnl
 916 dnl     LIBS
 917 dnl
 918 dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
 919 dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
 920 dnl We keep it around for reference purposes in case it's ever
 921 dnl useful in the future.
 922 dnl
 923
 924 define(AC_LBL_CHECK_LIB,
 925 [AC_MSG_CHECKING([for $2 in -l$1])
 926 dnl Use a cache variable name containing the library, function
 927 dnl name, and extra libraries to link with, because the test really is
 928 dnl for library $1 defining function $2, when linked with potinal
 929 dnl library $5, not just for library $1.  Separate tests with the same
 930 dnl $1 and different $2's or $5's may have different results.
 931 ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
 932 AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
 933 [ac_save_LIBS="$LIBS"
 934 LIBS="-l$1 $5 $LIBS"
 935 AC_TRY_LINK(dnl
 936 ifelse([$2], [main], , dnl Avoid conflicting decl of main.
 937 [/* Override any gcc2 internal prototype to avoid an error.  */
 938 ]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
 939 extern "C"
 940 #endif
 941 ])dnl
 942 [/* We use char because int might match the return type of a gcc2
 943     builtin and then its argument prototype would still apply.  */
 944 char $2();
 945 ]),
 946             [$2()],
 947             eval "ac_cv_lbl_lib_$ac_lib_var=yes",
 948             eval "ac_cv_lbl_lib_$ac_lib_var=no")
 949 LIBS="$ac_save_LIBS"
 950 ])dnl
 951 if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
 952   AC_MSG_RESULT(yes)
 953   ifelse([$3], ,
 954 [changequote(, )dnl
 955   ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
 956     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
 957 changequote([, ])dnl
 958   AC_DEFINE_UNQUOTED($ac_tr_lib)
 959   LIBS="-l$1 $LIBS"
 960 ], [$3])
 961 else
 962   AC_MSG_RESULT(no)
 963 ifelse([$4], , , [$4
 964 ])dnl
 965 fi
 966 ])
 967
 968 dnl
 969 dnl AC_LBL_LIBRARY_NET
 970 dnl
 971 dnl This test is for network applications that need socket() and
 972 dnl gethostbyname() -ish functions.  Under Solaris, those applications
 973 dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
 974 dnl with "-lnsl" but should *not* link with "-lsocket" because
 975 dnl libsocket.a breaks a number of things (for instance:
 976 dnl gethostbyname() under IRIX 5.2, and snoop sockets under most
 977 dnl versions of IRIX).
 978 dnl
 979 dnl Unfortunately, many application developers are not aware of this,
 980 dnl and mistakenly write tests that cause -lsocket to be used under
 981 dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
 982 dnl under operating systems where neither are necessary (or useful),
 983 dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
 984 dnl
 985 dnl This test exists so that every application developer does not test
 986 dnl this in a different, and subtly broken fashion.
 987
 988 dnl It has been argued that this test should be broken up into two
 989 dnl seperate tests, one for the resolver libraries, and one for the
 990 dnl libraries necessary for using Sockets API. Unfortunately, the two
 991 dnl are carefully intertwined and allowing the autoconf user to use
 992 dnl them independantly potentially results in unfortunate ordering
 993 dnl dependancies -- as such, such component macros would have to
 994 dnl carefully use indirection and be aware if the other components were
 995 dnl executed. Since other autoconf macros do not go to this trouble,
 996 dnl and almost no applications use sockets without the resolver, this
 997 dnl complexity has not been implemented.
 998 dnl
 999 dnl The check for libresolv is in case you are attempting to link
1000 dnl statically and happen to have a libresolv.a lying around (and no
1001 dnl libnsl.a).
1002 dnl
1003 AC_DEFUN(AC_LBL_LIBRARY_NET, [
1004     # Most operating systems have gethostbyname() in the default searched
1005     # libraries (i.e. libc):
1006     # Some OSes (eg. Solaris) place it in libnsl
1007     # Some strange OSes (SINIX) have it in libsocket:
1008     AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)
1009     # Unfortunately libsocket sometimes depends on libnsl and
1010     # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
1011     if test "$ac_cv_search_gethostbyname" = "no"
1012     then
1013         AC_CHECK_LIB(socket, gethostbyname,
1014                      LIBS="-lsocket -lnsl $LIBS", , -lnsl)
1015     fi
1016     AC_SEARCH_LIBS(socket, socket, ,
1017         AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
1018     # DLPI needs putmsg under HPUX so test for -lstr while we're at it
1019     AC_SEARCH_LIBS(putmsg, str)
1020     ])
1021
1022 dnl Copyright (c) 1999 WIDE Project. All rights reserved.
1023 dnl
1024 dnl Redistribution and use in source and binary forms, with or without
1025 dnl modification, are permitted provided that the following conditions
1026 dnl are met:
1027 dnl 1. Redistributions of source code must retain the above copyright
1028 dnl    notice, this list of conditions and the following disclaimer.
1029 dnl 2. Redistributions in binary form must reproduce the above copyright
1030 dnl    notice, this list of conditions and the following disclaimer in the
1031 dnl    documentation and/or other materials provided with the distribution.
1032 dnl 3. Neither the name of the project nor the names of its contributors
1033 dnl    may be used to endorse or promote products derived from this software
1034 dnl    without specific prior written permission.
1035 dnl
1036 dnl THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
1037 dnl ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1038 dnl IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1039 dnl ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
1040 dnl FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1041 dnl DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1042 dnl OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1043 dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1044 dnl LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1045 dnl OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1046 dnl SUCH DAMAGE.
1047
1048 dnl
1049 dnl Test for __attribute__
1050 dnl
1051
1052 AC_DEFUN(AC_C___ATTRIBUTE__, [
1053 AC_MSG_CHECKING(for __attribute__)
1054 AC_CACHE_VAL(ac_cv___attribute__, [
1055 AC_COMPILE_IFELSE([
1056   AC_LANG_SOURCE([[
1057 #include <stdlib.h>
1058
1059 static void foo(void) __attribute__ ((noreturn));
1060
1061 static void
1062 foo(void)
1063 {
1064   exit(1);
1065 }
1066
1067 int
1068 main(int argc, char **argv)
1069 {
1070   foo();
1071 }
1072   ]])],
1073 ac_cv___attribute__=yes,
1074 ac_cv___attribute__=no)])
1075 if test "$ac_cv___attribute__" = "yes"; then
1076   AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
1077 else
1078   #
1079   # We can't use __attribute__, so we can't use __attribute__((unused)),
1080   # so we define _U_ to an empty string.
1081   #
1082   V_DEFS="$V_DEFS -D_U_=\"\""
1083 fi
1084 AC_MSG_RESULT($ac_cv___attribute__)
1085 ])
1086
1087
1088 dnl
1089 dnl Test whether __attribute__((unused)) can be used without warnings
1090 dnl
1091
1092 AC_DEFUN(AC_C___ATTRIBUTE___UNUSED, [
1093 AC_MSG_CHECKING([whether __attribute__((unused)) can be used without warnings])
1094 AC_CACHE_VAL(ac_cv___attribute___unused, [
1095 save_CFLAGS="$CFLAGS"
1096 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"
1097 AC_COMPILE_IFELSE([
1098   AC_LANG_SOURCE([[
1099 #include <stdlib.h>
1100 #include <stdio.h>
1101
1102 int
1103 main(int argc  __attribute((unused)), char **argv __attribute((unused)))
1104 {
1105   printf("Hello, world!\n");
1106   return 0;
1107 }
1108   ]])],
1109 ac_cv___attribute___unused=yes,
1110 ac_cv___attribute___unused=no)])
1111 CFLAGS="$save_CFLAGS"
1112 if test "$ac_cv___attribute___unused" = "yes"; then
1113   V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""
1114 else
1115   V_DEFS="$V_DEFS -D_U_=\"\""
1116 fi
1117 AC_MSG_RESULT($ac_cv___attribute___unused)
1118 ])
1119
1120 dnl
1121 dnl Test whether __attribute__((fallthrough)) can be used without warnings
1122 dnl
1123
1124 AC_DEFUN(AC_C___ATTRIBUTE___FALLTHROUGH, [
1125 AC_MSG_CHECKING([whether __attribute__((fallthrough)) can be used without warnings])
1126 AC_CACHE_VAL(ac_cv___attribute___fallthrough, [
1127 save_CFLAGS="$CFLAGS"
1128 CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"
1129 AC_COMPILE_IFELSE([
1130   AC_LANG_SOURCE([[
1131 #include <stdio.h>
1132
1133 int
1134 main(int argc, char **argv)
1135 {
1136         int x = 1;
1137         switch (x)
1138         {
1139         case 1:
1140                 printf ("x == %d\n", x);
1141                 __attribute__ ((fallthrough));
1142         case 2:
1143                 printf ("x == %d\n", x);
1144                 break;
1145         default:
1146                 return 0;
1147         }
1148         return x;
1149 }
1150   ]])],
1151 ac_cv___attribute___fallthrough=yes,
1152 ac_cv___attribute___fallthrough=no)])
1153 CFLAGS="$save_CFLAGS"
1154 if test "$ac_cv___attribute___fallthrough" = "yes"; then
1155   AC_DEFINE(__ATTRIBUTE___FALLTHROUGH_OK, 1,
1156     [define if your compiler allows __attribute__((fallthrough)) without a warning])
1157 fi
1158 AC_MSG_RESULT($ac_cv___attribute___fallthrough)
1159 ])
1160
1161 AC_DEFUN(AC_LBL_SSLEAY,
1162     [
1163         #
1164         # Find the last component of $libdir; it's not necessarily
1165         # "lib" - it might be "lib64" on, for example, x86-64
1166         # Linux systems.
1167         #
1168         # We assume the directory in which we're looking for
1169         # libcrypto has a subdirectory with that as its name.
1170         #
1171         tmplib=`echo "$libdir" | sed 's,.*/,,'`
1172
1173         #
1174         # XXX - is there a better way to check if a given library is
1175         # in a given directory than checking each of the possible
1176         # shared library suffixes?
1177         #
1178         # Are there any other suffixes we need to look for?  Do we
1179         # have to worry about ".so.{version}"?
1180         #
1181         # Or should we just look for "libcrypto.*"?
1182         #
1183         if test -d "$1/$tmplib" -a \( -f "$1/$tmplib/libcrypto.a" -o \
1184                                     -f "$1/$tmplib/libcrypto.so" -o \
1185                                     -f "$1/$tmplib/libcrypto.sl" -o \
1186                                     -f "$1/$tmplib/libcrypto.dylib" \); then
1187                 ac_cv_ssleay_path="$1"
1188         fi
1189
1190         #
1191         # Make sure we have the headers as well.
1192         #
1193         if test -d "$1/include/openssl" -a -f "$1/include/openssl/des.h"; then
1194                 incdir="-I$1/include"
1195         fi
1196 ])