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_DEVEL])
  43     AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
  44     $1=""
  45     if test "${srcdir}" != "." ; then
  46             $1="-I$srcdir"
  47     fi
  48     if test "${CFLAGS+set}" = set; then
  49             LBL_CFLAGS="$CFLAGS"
  50     fi
  51     if test -z "$CC" ; then
  52             case "$host_os" in
  53
  54             bsdi*)
  55                     AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
  56                     if test $SHLICC2 = yes ; then
  57                             CC=shlicc2
  58                             export CC
  59                     fi
  60                     ;;
  61             esac
  62     fi
  63     if test -z "$CC" -a "$with_gcc" = no ; then
  64             CC=cc
  65             export CC
  66     fi
  67 ])
  68
  69 dnl
  70 dnl Determine which compiler we're using (cc or gcc)
  71 dnl If using gcc, determine the version number
  72 dnl If using cc:
  73 dnl     require that it support ansi prototypes
  74 dnl     use -O (AC_PROG_CC will use -g -O2 on gcc, so we don't need to
  75 dnl     do that ourselves for gcc)
  76 dnl     add -g flags, as appropriate
  77 dnl     explicitly specify /usr/local/include
  78 dnl
  79 dnl NOTE WELL: with newer versions of autoconf, "gcc" means any compiler
  80 dnl that defines __GNUC__, which means clang, for example, counts as "gcc".
  81 dnl
  82 dnl usage:
  83 dnl
  84 dnl     AC_LBL_C_INIT(copt, incls)
  85 dnl
  86 dnl results:
  87 dnl
  88 dnl     $1 (copt set)
  89 dnl     $2 (incls set)
  90 dnl     CC
  91 dnl     LDFLAGS
  92 dnl     LBL_CFLAGS
  93 dnl
  94 AC_DEFUN(AC_LBL_C_INIT,
  95 [
  96     AC_BEFORE([$0], [AC_LBL_DEVEL])
  97     if test "$GCC" = yes ; then
  98             #
  99             # -Werror forces warnings to be errors.
 100             #
 101             ac_lbl_cc_force_warning_errors=-Werror
 102     else
 103             $2="$$2 -I/usr/local/include"
 104             LDFLAGS="$LDFLAGS -L/usr/local/lib"
 105
 106             case "$host_os" in
 107
 108             darwin*)
 109                     #
 110                     # This is assumed either to be GCC or clang, both
 111                     # of which use -Werror to force warnings to be errors.
 112                     #
 113                     ac_lbl_cc_force_warning_errors=-Werror
 114                     ;;
 115
 116             hpux*)
 117                     #
 118                     # HP C, which is what we presume we're using, doesn't
 119                     # exit with a non-zero exit status if we hand it an
 120                     # invalid -W flag, can't be forced to do so even with
 121                     # +We, and doesn't handle GCC-style -W flags, so we
 122                     # don't want to try using GCC-style -W flags.
 123                     #
 124                     ac_lbl_cc_dont_try_gcc_dashW=yes
 125                     ;;
 126
 127             irix*)
 128                     #
 129                     # MIPS C, which is what we presume we're using, doesn't
 130                     # necessarily exit with a non-zero exit status if we
 131                     # hand it an invalid -W flag, can't be forced to do
 132                     # so, 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                     # It also, apparently, defaults to "char" being
 138                     # unsigned, unlike most other C implementations;
 139                     # I suppose we could say "signed char" whenever
 140                     # we want to guarantee a signed "char", but let's
 141                     # just force signed chars.
 142                     #
 143                     # -xansi is normally the default, but the
 144                     # configure script was setting it; perhaps -cckr
 145                     # was the default in the Old Days.  (Then again,
 146                     # that would probably be for backwards compatibility
 147                     # in the days when ANSI C was Shiny and New, i.e.
 148                     # 1989 and the early '90's, so maybe we can just
 149                     # drop support for those compilers.)
 150                     #
 151                     # -g is equivalent to -g2, which turns off
 152                     # optimization; we choose -g3, which generates
 153                     # debugging information but doesn't turn off
 154                     # optimization (even if the optimization would
 155                     # cause inaccuracies in debugging).
 156                     #
 157                     $1="$$1 -xansi -signed -g3"
 158                     ;;
 159
 160             osf*)
 161                     #
 162                     # Presumed to be DEC OSF/1, Digital UNIX, or
 163                     # Tru64 UNIX.
 164                     #
 165                     # The DEC C compiler, which is what we presume we're
 166                     # using, doesn't exit with a non-zero exit status if we
 167                     # hand it an invalid -W flag, can't be forced to do
 168                     # so, and doesn't handle GCC-style -W flags, so we
 169                     # don't want to try using GCC-style -W flags.
 170                     #
 171                     ac_lbl_cc_dont_try_gcc_dashW=yes
 172                     #
 173                     # -g is equivalent to -g2, which turns off
 174                     # optimization; we choose -g3, which generates
 175                     # debugging information but doesn't turn off
 176                     # optimization (even if the optimization would
 177                     # cause inaccuracies in debugging).
 178                     #
 179                     $1="$$1 -g3"
 180                     ;;
 181
 182             solaris*)
 183                     #
 184                     # Assumed to be Sun C, which requires -errwarn to force
 185                     # warnings to be treated as errors.
 186                     #
 187                     ac_lbl_cc_force_warning_errors=-errwarn
 188                     ;;
 189
 190             ultrix*)
 191                     AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
 192                     AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
 193                         AC_TRY_COMPILE(
 194                             [#include <sys/types.h>],
 195                             [struct a { int b; };
 196                             void c(const struct a *)],
 197                             ac_cv_lbl_cc_const_proto=yes,
 198                             ac_cv_lbl_cc_const_proto=no))
 199                     AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
 200                     if test $ac_cv_lbl_cc_const_proto = no ; then
 201                             AC_DEFINE(const,[],
 202                                 [to handle Ultrix compilers that don't support const in prototypes])
 203                     fi
 204                     ;;
 205             esac
 206             $1="$$1 -O"
 207     fi
 208 ])
 209
 210 dnl
 211 dnl Check whether the compiler option specified as the second argument
 212 dnl is supported by the compiler and, if so, add it to the macro
 213 dnl specified as the first argument
 214 dnl
 215 AC_DEFUN(AC_LBL_CHECK_COMPILER_OPT,
 216     [
 217         AC_MSG_CHECKING([whether the compiler supports the $2 option])
 218         save_CFLAGS="$CFLAGS"
 219         CFLAGS="$CFLAGS $2"
 220         #
 221         # XXX - yes, this depends on the way AC_LANG_WERROR works,
 222         # but no mechanism is provided to turn AC_LANG_WERROR on
 223         # *and then turn it back off*, so that we *only* do it when
 224         # testing compiler options - 15 years after somebody asked
 225         # for it:
 226         #
 227         #     https://autoconf.gnu.narkive.com/gTAVmfKD/how-to-cancel-flags-set-by-ac-lang-werror
 228         #
 229         save_ac_c_werror_flag="$ac_c_werror_flag"
 230         ac_c_werror_flag=yes
 231         #
 232         # We use AC_LANG_SOURCE() so that we can control the complete
 233         # content of the program being compiled.  We do not, for example,
 234         # want the default "int main()" that AC_LANG_PROGRAM() generates,
 235         # as it will generate a warning with -Wold-style-definition, meaning
 236         # that we would treat it as not working, as the test will fail if
 237         # *any* error output, including a warning due to the flag we're
 238         # testing, is generated; see
 239         #
 240         #    https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us
 241         #    https://www.postgresql.org/message-id/2192993.1591682589%40sss.pgh.pa.us
 242         #
 243         # This may, as per those two messages, be fixed in autoconf 2.70,
 244         # but we only require 2.64 or newer for now.
 245         #
 246         AC_COMPILE_IFELSE(
 247             [AC_LANG_SOURCE([[int main(void) { return 0; }]])],
 248             [
 249                 AC_MSG_RESULT([yes])
 250                 CFLAGS="$save_CFLAGS"
 251                 $1="$$1 $2"
 252             ],
 253             [
 254                 AC_MSG_RESULT([no])
 255                 CFLAGS="$save_CFLAGS"
 256             ])
 257         ac_c_werror_flag="$save_ac_c_werror_flag"
 258     ])
 259
 260 dnl
 261 dnl Check whether the compiler supports an option to generate
 262 dnl Makefile-style dependency lines
 263 dnl
 264 dnl GCC uses -M for this.  Non-GCC compilers that support this
 265 dnl use a variety of flags, including but not limited to -M.
 266 dnl
 267 dnl We test whether the flag in question is supported, as older
 268 dnl versions of compilers might not support it.
 269 dnl
 270 dnl We don't try all the possible flags, just in case some flag means
 271 dnl "generate dependencies" on one compiler but means something else
 272 dnl on another compiler.
 273 dnl
 274 dnl Most compilers that support this send the output to the standard
 275 dnl output by default.  IBM's XLC, however, supports -M but sends
 276 dnl the output to {sourcefile-basename}.u, and AIX has no /dev/stdout
 277 dnl to work around that, so we don't bother with XLC.
 278 dnl
 279 AC_DEFUN(AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT,
 280     [
 281         AC_MSG_CHECKING([whether the compiler supports generating dependencies])
 282         if test "$GCC" = yes ; then
 283                 #
 284                 # GCC, or a compiler deemed to be GCC by AC_PROG_CC (even
 285                 # though it's not); we assume that, in this case, the flag
 286                 # would be -M.
 287                 #
 288                 ac_lbl_dependency_flag="-M"
 289         else
 290                 #
 291                 # Not GCC or a compiler deemed to be GCC; what platform is
 292                 # this?  (We're assuming that if the compiler isn't GCC
 293                 # it's the compiler from the vendor of the OS; that won't
 294                 # necessarily be true for x86 platforms, where it might be
 295                 # the Intel C compiler.)
 296                 #
 297                 case "$host_os" in
 298
 299                 irix*|osf*|darwin*)
 300                         #
 301                         # MIPS C for IRIX, DEC C, and clang all use -M.
 302                         #
 303                         ac_lbl_dependency_flag="-M"
 304                         ;;
 305
 306                 solaris*)
 307                         #
 308                         # Sun C uses -xM.
 309                         #
 310                         ac_lbl_dependency_flag="-xM"
 311                         ;;
 312
 313                 hpux*)
 314                         #
 315                         # HP's older C compilers don't support this.
 316                         # HP's newer C compilers support this with
 317                         # either +M or +Make; the older compilers
 318                         # interpret +M as something completely
 319                         # different, so we use +Make so we don't
 320                         # think it works with the older compilers.
 321                         #
 322                         ac_lbl_dependency_flag="+Make"
 323                         ;;
 324
 325                 *)
 326                         #
 327                         # Not one of the above; assume no support for
 328                         # generating dependencies.
 329                         #
 330                         ac_lbl_dependency_flag=""
 331                         ;;
 332                 esac
 333         fi
 334
 335         #
 336         # Is ac_lbl_dependency_flag defined and, if so, does the compiler
 337         # complain about it?
 338         #
 339         # Note: clang doesn't seem to exit with an error status when handed
 340         # an unknown non-warning error, even if you pass it
 341         # -Werror=unknown-warning-option.  However, it always supports
 342         # -M, so the fact that this test always succeeds with clang
 343         # isn't an issue.
 344         #
 345         if test ! -z "$ac_lbl_dependency_flag"; then
 346                 AC_LANG_CONFTEST(
 347                     [AC_LANG_SOURCE([[int main(void) { return 0; }]])])
 348                 if AC_RUN_LOG([eval "$CC $ac_lbl_dependency_flag conftest.c >/dev/null 2>&1"]); then
 349                         AC_MSG_RESULT([yes, with $ac_lbl_dependency_flag])
 350                         DEPENDENCY_CFLAG="$ac_lbl_dependency_flag"
 351                         MKDEP='${top_srcdir}/mkdep'
 352                 else
 353                         AC_MSG_RESULT([no])
 354                         #
 355                         # We can't run mkdep, so have "make depend" do
 356                         # nothing.
 357                         #
 358                         MKDEP=:
 359                 fi
 360                 rm -rf conftest*
 361         else
 362                 AC_MSG_RESULT([no])
 363                 #
 364                 # We can't run mkdep, so have "make depend" do
 365                 # nothing.
 366                 #
 367                 MKDEP=:
 368         fi
 369         AC_SUBST(DEPENDENCY_CFLAG)
 370         AC_SUBST(MKDEP)
 371     ])
 372
 373 dnl
 374 dnl Require libpcap
 375 dnl Look for libpcap in directories under ..; those are local versions.
 376 dnl Look for an installed libpcap if there is no local version or if
 377 dnl the user said not to look for a local version.
 378 dnl
 379 dnl usage:
 380 dnl
 381 dnl     AC_LBL_LIBPCAP(pcapdep, incls)
 382 dnl
 383 dnl results:
 384 dnl
 385 dnl     $1 (pcapdep set)
 386 dnl     $2 (incls appended)
 387 dnl     LIBS
 388 dnl
 389 AC_DEFUN(AC_LBL_LIBPCAP,
 390     [AC_REQUIRE([AC_LBL_LIBRARY_NET])
 391     libpcap=FAIL
 392     AC_MSG_CHECKING([whether to look for a local libpcap])
 393     AC_ARG_ENABLE(local-libpcap,
 394         AS_HELP_STRING([--disable-local-libpcap],
 395                        [don't look for a local libpcap @<:@default=check for a local libpcap@:>@]),,
 396         enableval=yes)
 397     case "$enableval" in
 398
 399     no)
 400         AC_MSG_RESULT(no)
 401         #
 402         # Don't look for a local libpcap.
 403         #
 404         using_local_libpcap=no
 405         ;;
 406
 407     *)
 408         AC_MSG_RESULT(yes)
 409         #
 410         # Look for a local pcap library.
 411         #
 412         AC_MSG_CHECKING(for local pcap library)
 413         lastdir=FAIL
 414         places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 415             egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT|rc.)?$'`
 416         places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 417             egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT|rc.)?$'`
 418         for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 419             basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//' | \
 420                 sed -e 's/-PRE-GIT$//' `
 421             if test $lastdir = $basedir ; then
 422                 dnl skip alphas when an actual release is present
 423                 continue;
 424             fi
 425             lastdir=$dir
 426             if test -r $dir/libpcap.a ; then
 427                 libpcap=$dir/libpcap.a
 428                 local_pcap_dir=$dir
 429                 dnl continue and select the last one that exists
 430             fi
 431         done
 432         if test $libpcap = FAIL ; then
 433             #
 434             # We didn't find a local libpcap.
 435             #
 436             AC_MSG_RESULT(not found)
 437             using_local_libpcap=no;
 438         else
 439             #
 440             # We found a local libpcap.
 441             #
 442             AC_MSG_RESULT($libpcap)
 443             using_local_libpcap=yes
 444         fi
 445         ;;
 446     esac
 447
 448     if test $using_local_libpcap = no ; then
 449         #
 450         # We didn't find a local libpcap.
 451         # Look for an installed pkg-config.
 452         #
 453         AC_PATH_TOOL(PKG_CONFIG, pkg-config)
 454         if test -n "$PKG_CONFIG" ; then
 455             #
 456             # We have it.  Are there .pc files for libpcap?
 457             #
 458             # --exists was introduced in pkg-config 0.4.0; that
 459             # dates back to late 2000, so we won't worry about
 460             # earlier releases that lack it.
 461             #
 462             AC_MSG_CHECKING(whether there are .pc files for libpcap)
 463             if "$PKG_CONFIG" libpcap --exists ; then
 464                 #
 465                 # Yes, so we can use pkg-config to get configuration
 466                 # information for libpcap.
 467                 #
 468                 AC_MSG_RESULT(yes)
 469                 pkg_config_usable=yes
 470             else
 471                 #
 472                 # No, so we can't use pkg-config to get configuration
 473                 # information for libpcap.
 474                 #
 475                 AC_MSG_RESULT(no)
 476                 pkg_config_usable=no
 477             fi
 478         else
 479             #
 480             # We don't have it, so we obviously can't use it.
 481             #
 482             pkg_config_usable=no
 483         fi
 484         if test "$pkg_config_usable" = "yes" ; then
 485             #
 486             # Found both - use pkg-config to get the include flags for
 487             # libpcap and the flags to link with libpcap.
 488             #
 489             # Please read section 11.6 "Shell Substitutions"
 490             # in the autoconf manual before doing anything
 491             # to this that involves quoting.  Especially note
 492             # the statement "There is just no portable way to use
 493             # double-quoted strings inside double-quoted back-quoted
 494             # expressions (pfew!)."
 495             #
 496             cflags=`"$PKG_CONFIG" libpcap --cflags`
 497             $2="$cflags $$2"
 498             libpcap=`"$PKG_CONFIG" libpcap --libs`
 499         else
 500             #
 501             # No pkg-config
 502             # Look for an installed pcap-config.
 503             #
 504             AC_PATH_TOOL(PCAP_CONFIG, pcap-config)
 505             if test -n "$PCAP_CONFIG" ; then
 506                 #
 507                 # Found - use it to get the include flags for
 508                 # libpcap and the flags to link with libpcap.
 509                 #
 510                 # If this is a vendor-supplied pcap-config, which
 511                 # we define as being "a pcap-config in /usr/bin
 512                 # or /usr/ccs/bin" (the latter is for Solaris and
 513                 # Sun/Oracle Studio), there are some issues.  Work
 514                 # around them.
 515                 #
 516                 if test \( "$PCAP_CONFIG" = "/usr/bin/pcap-config" \) -o \
 517                         \( "$PCAP_CONFIG" = "/usr/ccs/bin/pcap-config" \) ; then
 518                     #
 519                     # It's vendor-supplied.
 520                     #
 521                     case "$host_os" in
 522
 523                     darwin*)
 524                         #
 525                         # This is macOS or another Darwin-based OS.
 526                         #
 527                         # That means that /usr/bin/pcap-config it
 528                         # may provide -I/usr/local/include with --cflags
 529                         # and -L/usr/local/lib with --libs, rather than
 530                         # pointing to the OS-supplied library and
 531                         # Xcode-supplied headers.  Remember that, so we
 532                         # ignore those values.
 533                         #
 534                         _broken_apple_pcap_config=yes
 535                         ;;
 536
 537                     solaris*)
 538                         #
 539                         # This is Solaris 2 or later, i.e. SunOS 5.x.
 540                         #
 541                         # At least on Solaris 11; there's /usr/bin/pcap-config,
 542                         # which reports -L/usr/lib with --libs, causing
 543                         # the 32-bit libraries to be found, and there's
 544                         # /usr/bin/{64bitarch}/pcap-config, where {64bitarch}
 545                         # is a name for the 64-bit version of the instruction
 546                         # set, which reports -L /usr/lib/{64bitarch}, causing
 547                         # the 64-bit libraries to be found.
 548                         #
 549                         # So if we're building 64-bit targets, we replace
 550                         # PCAP_CONFIG with /usr/bin/{64bitarch}; we get
 551                         # {64bitarch} as the output of "isainfo -n".
 552                         #
 553                         # Are we building 32-bit or 64-bit?  Get the
 554                         # size of void *, and check that.
 555                         #
 556                         AC_CHECK_SIZEOF([void *])
 557                         if test ac_cv_sizeof_void_p -eq 8 ; then
 558                             isainfo_output=`isainfo -n`
 559                             if test ! -z "$isainfo_output" ; then
 560                                 #
 561                                 # Success - change PCAP_CONFIG.
 562                                 #
 563                                 PCAP_CONFIG=`echo $PCAP_CONFIG | sed "s;/bin/;/bin/$isainfo_output/;"`
 564                             fi
 565                         fi
 566                         ;;
 567                     esac
 568                 fi
 569                 #
 570                 # Please read section 11.6 "Shell Substitutions"
 571                 # in the autoconf manual before doing anything
 572                 # to this that involves quoting.  Especially note
 573                 # the statement "There is just no portable way to use
 574                 # double-quoted strings inside double-quoted back-quoted
 575                 # expressions (pfew!)."
 576                 #
 577                 cflags=`"$PCAP_CONFIG" --cflags`
 578                 #
 579                 # Work around macOS (and probably other Darwin) brokenness,
 580                 # by not adding /usr/local/include if it's from the broken
 581                 # Apple pcap-config.
 582                 #
 583                 if test "$_broken_apple_pcap_config" = "yes" ; then
 584                     #
 585                     # Strip -I/usr/local/include with sed.
 586                     #
 587                     cflags=`echo $cflags | sed 's;-I/usr/local/include;;'`
 588                 fi
 589                 $2="$cflags $$2"
 590                 libpcap=`"$PCAP_CONFIG" --libs`
 591                 #
 592                 # Work around macOS (and probably other Darwin) brokenness,
 593                 # by not adding /usr/local/lib if it's from the broken
 594                 # Apple pcap-config.
 595                 #
 596                 if test "$_broken_apple_pcap_config" = "yes" ; then
 597                     #
 598                     # Strip -L/usr/local/lib with sed.
 599                     #
 600                     libpcap=`echo $libpcap | sed 's;-L/usr/local/lib;;'`
 601                 fi
 602             else
 603                 #
 604                 # Not found; look for an installed pcap.
 605                 #
 606                 AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
 607                 if test $libpcap = FAIL ; then
 608                     AC_MSG_ERROR(see the INSTALL.md file for more info)
 609                 fi
 610                 dnl
 611                 dnl Some versions of Red Hat Linux put "pcap.h" in
 612                 dnl "/usr/include/pcap"; had the LBL folks done so,
 613                 dnl that would have been a good idea, but for
 614                 dnl the Red Hat folks to do so just breaks source
 615                 dnl compatibility with other systems.
 616                 dnl
 617                 dnl We work around this by assuming that, as we didn't
 618                 dnl find a local libpcap, libpcap is in /usr/lib or
 619                 dnl /usr/local/lib and that the corresponding header
 620                 dnl file is under one of those directories; if we don't
 621                 dnl find it in either of those directories, we check to
 622                 dnl see if it's in a "pcap" subdirectory of them and,
 623                 dnl if so, add that subdirectory to the "-I" list.
 624                 dnl
 625                 dnl (We now also put pcap.h in /usr/include/pcap, but we
 626                 dnl leave behind a /usr/include/pcap.h that includes it,
 627                 dnl so you can still just include <pcap.h>.)
 628                 dnl
 629                 AC_MSG_CHECKING(for extraneous pcap header directories)
 630                 if test \( ! -r /usr/local/include/pcap.h \) -a \
 631                         \( ! -r /usr/include/pcap.h \); then
 632                     if test -r /usr/local/include/pcap/pcap.h; then
 633                         d="/usr/local/include/pcap"
 634                     elif test -r /usr/include/pcap/pcap.h; then
 635                         d="/usr/include/pcap"
 636                     fi
 637                 fi
 638                 if test -z "$d" ; then
 639                     AC_MSG_RESULT(not found)
 640                 else
 641                     $2="-I$d $$2"
 642                     AC_MSG_RESULT(found -- -I$d added)
 643                 fi
 644             fi
 645         fi
 646     else
 647         #
 648         # We found a local libpcap.  Add it to the dependencies for
 649         # tcpdump.
 650         #
 651         $1=$libpcap
 652
 653         #
 654         # Look for its pcap-config script.
 655         #
 656         AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $local_pcap_dir)
 657
 658         if test -n "$PCAP_CONFIG"; then
 659             #
 660             # We don't want its --cflags or --libs output, because
 661             # those presume it's installed.  For the C compiler flags,
 662             # we add the source directory for the local libpcap, so
 663             # we pick up its header files.
 664             #
 665             # We do, however, want its additional libraries, as required
 666             # when linking statically, because it makes calls to
 667             # routines in those libraries, so we'll need to link with
 668             # them, because we'll be linking statically with it.
 669             #
 670             # If it supports --static-pcap-only. use that, as we will be
 671             # linking with a static libpcap but won't be linking
 672             # statically with any of the libraries on which it depends;
 673             # those libraries might not even have static versions
 674             # installed.
 675             #
 676             # That means we need to find out the libraries on which
 677             # libpcap directly depends, so we can link with them, but we
 678             # don't need to link with the libraries on which those
 679             # libraries depend as, on all UN*Xes with which I'm
 680             # familiar, the libraries on which a shared library depends
 681             # are stored in the library and are automatically loaded by
 682             # the run-time linker, without the executable having to be
 683             # linked with those libraries.  (This allows a library to be
 684             # changed to depend on more libraries without breaking that
 685             # library's ABI.)
 686             #
 687             # The only way to test for that support is to see if the
 688             # script contains the string "static-pcap-only"; we can't
 689             # try using that flag and checking for errors, as the
 690             # versions of the script that didn't have that flag wouldn't
 691             # report or return an error for an unsupported command-line
 692             # flag.  Those older versions provided, with --static, only
 693             # the libraries on which libpcap depends, not the
 694             # dependencies of those libraries; the versions with
 695             # --static-pcap-only provide all the dependencies with
 696             # --static, for the benefit of programs that are completely
 697             # statically linked, and provide only the direct
 698             # dependencies with --static-pcap-only.
 699             #
 700             if grep -s -q "static-pcap-only" "$PCAP_CONFIG"
 701             then
 702                 static_opt="--static-pcap-only"
 703             else
 704                 static_opt="--static"
 705             fi
 706             $2="-I$local_pcap_dir $$2"
 707             additional_libs=`"$PCAP_CONFIG" $static_opt --additional-libs`
 708             libpcap="$libpcap $additional_libs"
 709         else
 710             #
 711             # It doesn't have a pcap-config script.
 712             # Make sure it has a pcap.h file.
 713             #
 714             places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 715                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 716             places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 717                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 718             pcapH=FAIL
 719             if test -r $local_pcap_dir/pcap.h; then
 720                 pcapH=$local_pcap_dir
 721             else
 722                 for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 723                     if test -r $dir/pcap.h ; then
 724                         pcapH=$dir
 725                     fi
 726                 done
 727             fi
 728
 729             if test $pcapH = FAIL ; then
 730                 AC_MSG_ERROR(cannot find pcap.h: see the INSTALL.md file)
 731             fi
 732
 733             #
 734             # Force the compiler to look for header files in the
 735             # directory containing pcap.h.
 736             #
 737             $2="-I$pcapH $$2"
 738         fi
 739     fi
 740
 741     if test -z "$PKG_CONFIG" -a -z "$PCAP_CONFIG"; then
 742         #
 743         # We don't have pkg-config or pcap-config; find out any additional
 744         # link flags we need.  (If we have pkg-config or pcap-config, we
 745         # assume it tells us what we need.)
 746         #
 747         case "$host_os" in
 748
 749         aix*)
 750             #
 751             # If libpcap is DLPI-based, we have to use /lib/pse.exp if
 752             # present, as we use the STREAMS routines.
 753             #
 754             # (XXX - true only if we're linking with a static libpcap?)
 755             #
 756             pseexe="/lib/pse.exp"
 757             AC_MSG_CHECKING(for $pseexe)
 758             if test -f $pseexe ; then
 759                 AC_MSG_RESULT(yes)
 760                 LIBS="$LIBS -I:$pseexe"
 761             fi
 762
 763             #
 764             # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as
 765             # we use them to load the BPF module.
 766             #
 767             # (XXX - true only if we're linking with a static libpcap?)
 768             #
 769             LIBS="$LIBS -lodm -lcfg"
 770             ;;
 771
 772         solaris*)
 773             # libdlpi is needed for Solaris 11 and later.
 774             AC_CHECK_LIB(dlpi, dlpi_walk, LIBS="$LIBS -ldlpi" LDFLAGS="-L/lib $LDFLAGS", ,-L/lib)
 775             ;;
 776         esac
 777     fi
 778
 779     LIBS="$libpcap $LIBS"
 780
 781     dnl
 782     dnl Check for "pcap_loop()", to make sure we found a working
 783     dnl libpcap and have all the right other libraries with which
 784     dnl to link.  (Otherwise, the checks below will fail, not
 785     dnl because the routines are missing from the library, but
 786     dnl because we aren't linking properly with libpcap, and
 787     dnl that will cause confusing errors at build time.)
 788     dnl
 789     AC_CHECK_FUNC(pcap_loop,,
 790     [
 791         AC_MSG_ERROR(
 792 [This is a bug, please follow the guidelines in CONTRIBUTING.md and include the
 793 config.log file in your report.  If you have downloaded libpcap from
 794 tcpdump.org, and built it yourself, please also include the config.log
 795 file from the libpcap source directory, the Makefile from the libpcap
 796 source directory, and the output of the make process for libpcap, as
 797 this could be a problem with the libpcap that was built, and we will
 798 not be able to determine why this is happening, and thus will not be
 799 able to fix it, without that information, as we have not been able to
 800 reproduce this problem ourselves.])
 801     ])
 802 ])
 803
 804 dnl
 805 dnl If the file .devel exists:
 806 dnl     Add some warning flags if the compiler supports them
 807 dnl     If an os prototype include exists, symlink os-proto.h to it
 808 dnl
 809 dnl usage:
 810 dnl
 811 dnl     AC_LBL_DEVEL(copt)
 812 dnl
 813 dnl results:
 814 dnl
 815 dnl     $1 (copt appended)
 816 dnl     HAVE_OS_PROTO_H (defined)
 817 dnl     os-proto.h (symlinked)
 818 dnl
 819 AC_DEFUN(AC_LBL_DEVEL,
 820     [rm -f os-proto.h
 821     if test "${LBL_CFLAGS+set}" = set; then
 822             $1="$$1 ${LBL_CFLAGS}"
 823     fi
 824     if test -f .devel ; then
 825             #
 826             # Skip all the warning option stuff on some compilers.
 827             #
 828             if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then
 829                     AC_LBL_CHECK_COMPILER_OPT($1, -W)
 830                     AC_LBL_CHECK_COMPILER_OPT($1, -Wall)
 831                     AC_LBL_CHECK_COMPILER_OPT($1, -Wassign-enum)
 832                     AC_LBL_CHECK_COMPILER_OPT($1, -Wcast-qual)
 833                     AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)
 834                     AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-variable-declarations)
 835                     AC_LBL_CHECK_COMPILER_OPT($1, -Wold-style-definition)
 836                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpedantic)
 837                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith)
 838                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-sign)
 839                     AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)
 840                     AC_LBL_CHECK_COMPILER_OPT($1, -Wsign-compare)
 841                     AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)
 842                     AC_LBL_CHECK_COMPILER_OPT($1, -Wunreachable-code-return)
 843                     AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused)
 844                     AC_LBL_CHECK_COMPILER_OPT($1, -Wwrite-strings)
 845             fi
 846             AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()
 847             #
 848             # We used to set -n32 for IRIX 6 when not using GCC (presumed
 849             # to mean that we're using MIPS C or MIPSpro C); it specified
 850             # the "new" faster 32-bit ABI, introduced in IRIX 6.2.  I'm
 851             # not sure why that would be something to do *only* with a
 852             # .devel file; why should the ABI for which we produce code
 853             # depend on .devel?
 854             #
 855             os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
 856             name="lbl/os-$os.h"
 857             if test -f $name ; then
 858                     ln -s $name os-proto.h
 859                     AC_DEFINE(HAVE_OS_PROTO_H, 1,
 860                         [if there's an os_proto.h for this platform, to use additional prototypes])
 861             else
 862                     AC_MSG_WARN(can't find $name)
 863             fi
 864     fi])
 865
 866 dnl
 867 dnl AC_LBL_LIBRARY_NET
 868 dnl
 869 dnl This test is for network applications that need socket() and
 870 dnl gethostbyaddr() -ish functions.  Under Solaris, those applications
 871 dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
 872 dnl with "-lnsl" but should *not* link with "-lsocket" because
 873 dnl libsocket.a breaks a number of things (for instance:
 874 dnl gethostbyaddr() under IRIX 5.2, and snoop sockets under most
 875 dnl versions of IRIX).
 876 dnl
 877 dnl Unfortunately, many application developers are not aware of this,
 878 dnl and mistakenly write tests that cause -lsocket to be used under
 879 dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
 880 dnl under operating systems where neither are necessary (or useful),
 881 dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
 882 dnl
 883 dnl This test exists so that every application developer does not test
 884 dnl this in a different, and subtly broken fashion.
 885
 886 dnl It has been argued that this test should be broken up into two
 887 dnl separate tests, one for the resolver libraries, and one for the
 888 dnl libraries necessary for using Sockets API. Unfortunately, the two
 889 dnl are carefully intertwined and allowing the autoconf user to use
 890 dnl them independently potentially results in unfortunate ordering
 891 dnl dependencies -- as such, such component macros would have to
 892 dnl carefully use indirection and be aware if the other components were
 893 dnl executed. Since other autoconf macros do not go to this trouble,
 894 dnl and almost no applications use sockets without the resolver, this
 895 dnl complexity has not been implemented.
 896 dnl
 897 dnl The check for libresolv is in case you are attempting to link
 898 dnl statically and happen to have a libresolv.a lying around (and no
 899 dnl libnsl.a).
 900 dnl
 901 AC_DEFUN(AC_LBL_LIBRARY_NET, [
 902     # Most operating systems have gethostbyaddr() in the default searched
 903     # libraries (i.e. libc):
 904     # Some OSes (eg. Solaris) place it in libnsl
 905     # Some strange OSes (SINIX) have it in libsocket:
 906     AC_SEARCH_LIBS(gethostbyaddr, network nsl socket resolv)
 907     # Unfortunately libsocket sometimes depends on libnsl and
 908     # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
 909     if test "$ac_cv_search_gethostbyaddr" = "no"
 910     then
 911         AC_CHECK_LIB(socket, gethostbyaddr,
 912                      LIBS="-lsocket -lnsl $LIBS", , -lnsl)
 913     fi
 914     AC_SEARCH_LIBS(socket, socket, ,
 915         AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
 916     # DLPI needs putmsg under HPUX so test for -lstr while we're at it
 917     AC_SEARCH_LIBS(putmsg, str)
 918     ])