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 #
 374 # Try compiling a sample of the type of code that appears in
 375 # gencode.c with "inline", "__inline__", and "__inline".
 376 #
 377 # Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
 378 # as it just tests whether a function returning "int" can be inlined;
 379 # at least some versions of HP's C compiler can inline that, but can't
 380 # inline a function that returns a struct pointer.
 381 #
 382 # Make sure we use the V_CCOPT flags, because some of those might
 383 # disable inlining.
 384 #
 385 AC_DEFUN(AC_LBL_C_INLINE,
 386     [AC_MSG_CHECKING(for inline)
 387     save_CFLAGS="$CFLAGS"
 388     CFLAGS="$V_CCOPT"
 389     AC_CACHE_VAL(ac_cv_lbl_inline, [
 390         ac_cv_lbl_inline=""
 391         ac_lbl_cc_inline=no
 392         for ac_lbl_inline in inline __inline__ __inline
 393         do
 394             AC_TRY_COMPILE(
 395                 [#define inline $ac_lbl_inline
 396                 static inline struct iltest *foo(void);
 397                 struct iltest {
 398                     int iltest1;
 399                     int iltest2;
 400                 };
 401
 402                 static inline struct iltest *
 403                 foo()
 404                 {
 405                     static struct iltest xxx;
 406
 407                     return &xxx;
 408                 }],,ac_lbl_cc_inline=yes,)
 409             if test "$ac_lbl_cc_inline" = yes ; then
 410                 break;
 411             fi
 412         done
 413         if test "$ac_lbl_cc_inline" = yes ; then
 414             ac_cv_lbl_inline=$ac_lbl_inline
 415         fi])
 416     CFLAGS="$save_CFLAGS"
 417     if test ! -z "$ac_cv_lbl_inline" ; then
 418         AC_MSG_RESULT($ac_cv_lbl_inline)
 419     else
 420         AC_MSG_RESULT(no)
 421     fi
 422     AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
 423
 424 dnl
 425 dnl Use pfopen.c if available and pfopen() not in standard libraries
 426 dnl Require libpcap
 427 dnl Look for libpcap in directories under ..; those are local versions.
 428 dnl Look for an installed libpcap if there is no local version or if
 429 dnl the user said not to look for a local version.
 430 dnl
 431 dnl usage:
 432 dnl
 433 dnl     AC_LBL_LIBPCAP(pcapdep, incls)
 434 dnl
 435 dnl results:
 436 dnl
 437 dnl     $1 (pcapdep set)
 438 dnl     $2 (incls appended)
 439 dnl     LIBS
 440 dnl     LBL_LIBS
 441 dnl
 442 AC_DEFUN(AC_LBL_LIBPCAP,
 443     [AC_REQUIRE([AC_LBL_LIBRARY_NET])
 444     dnl
 445     dnl save a copy before locating libpcap.a
 446     dnl
 447     LBL_LIBS="$LIBS"
 448     pfopen=/usr/examples/packetfilter/pfopen.c
 449     if test -f $pfopen ; then
 450         AC_CHECK_FUNCS(pfopen)
 451         if test $ac_cv_func_pfopen = "no" ; then
 452             AC_MSG_RESULT(Using $pfopen)
 453             LIBS="$LIBS $pfopen"
 454         fi
 455     fi
 456     libpcap=FAIL
 457     AC_MSG_CHECKING([whether to look for a local libpcap])
 458     AC_ARG_ENABLE(local-libpcap,
 459         AS_HELP_STRING([--disable-local-libpcap],
 460                        [don't look for a local libpcap @<:@default=check for a local libpcap@:>@]),,
 461         enableval=yes)
 462     case "$enableval" in
 463
 464     no)
 465         AC_MSG_RESULT(no)
 466         #
 467         # Don't look for a local libpcap.
 468         #
 469         using_local_libpcap=no
 470         ;;
 471
 472     *)
 473         AC_MSG_RESULT(yes)
 474         #
 475         # Look for a local pcap library.
 476         #
 477         AC_MSG_CHECKING(for local pcap library)
 478         lastdir=FAIL
 479         places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 480             egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT|rc.)?$'`
 481         places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 482             egrep '/libpcap-[[0-9]]+\.[[0-9]]+(\.[[0-9]]*)?([[ab]][[0-9]]*|-PRE-GIT|rc.)?$'`
 483         for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 484             basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//' | \
 485                 sed -e 's/-PRE-GIT$//' `
 486             if test $lastdir = $basedir ; then
 487                 dnl skip alphas when an actual release is present
 488                 continue;
 489             fi
 490             lastdir=$dir
 491             if test -r $dir/libpcap.a ; then
 492                 libpcap=$dir/libpcap.a
 493                 local_pcap_dir=$dir
 494                 dnl continue and select the last one that exists
 495             fi
 496         done
 497         if test $libpcap = FAIL ; then
 498             #
 499             # We didn't find a local libpcap.
 500             #
 501             AC_MSG_RESULT(not found)
 502             using_local_libpcap=no;
 503         else
 504             #
 505             # We found a local libpcap.
 506             #
 507             AC_MSG_RESULT($libpcap)
 508             using_local_libpcap=yes
 509         fi
 510         ;;
 511     esac
 512
 513     if test $using_local_libpcap = no ; then
 514         #
 515         # We didn't find a local libpcap.
 516         # Look for an installed pkg-config.
 517         #
 518         AC_PATH_TOOL(PKG_CONFIG, pkg-config)
 519         if test -n "$PKG_CONFIG" ; then
 520             #
 521             # We have it.  Are there .pc files for libpcap?
 522             #
 523             # --exists was introduced in pkg-config 0.4.0; that
 524             # dates back to late 2000, so we won't worry about
 525             # earlier releases that lack it.
 526             #
 527             AC_MSG_CHECKING(whether there are .pc files for libpcap)
 528             if "$PKG_CONFIG" libpcap --exists ; then
 529                 #
 530                 # Yes, so we can use pkg-config to get configuration
 531                 # information for libpcap.
 532                 #
 533                 AC_MSG_RESULT(yes)
 534                 pkg_config_usable=yes
 535             else
 536                 #
 537                 # No, so we can't use pkg-config to get configuration
 538                 # information for libpcap.
 539                 #
 540                 AC_MSG_RESULT(no)
 541                 pkg_config_usable=no
 542             fi
 543         else
 544             #
 545             # We don't have it, so we obviously can't use it.
 546             #
 547             pkg_config_usable=no
 548         fi
 549         if test "$pkg_config_usable" = "yes" ; then
 550             #
 551             # Found both - use pkg-config to get the include flags for
 552             # libpcap and the flags to link with libpcap.
 553             #
 554             # Please read section 11.6 "Shell Substitutions"
 555             # in the autoconf manual before doing anything
 556             # to this that involves quoting.  Especially note
 557             # the statement "There is just no portable way to use
 558             # double-quoted strings inside double-quoted back-quoted
 559             # expressions (pfew!)."
 560             #
 561             cflags=`"$PKG_CONFIG" libpcap --cflags`
 562             $2="$cflags $$2"
 563             libpcap=`"$PKG_CONFIG" libpcap --libs`
 564         else
 565             #
 566             # No pkg-config
 567             # Look for an installed pcap-config.
 568             #
 569             AC_PATH_TOOL(PCAP_CONFIG, pcap-config)
 570             if test -n "$PCAP_CONFIG" ; then
 571                 #
 572                 # Found - use it to get the include flags for
 573                 # libpcap and the flags to link with libpcap.
 574                 #
 575                 # If this is a vendor-supplied pcap-config, which
 576                 # we define as being "a pcap-config in /usr/bin
 577                 # or /usr/ccs/bin" (the latter is for Solaris and
 578                 # Sun/Oracle Studio), there are some issues.  Work
 579                 # around them.
 580                 #
 581                 if test \( "$PCAP_CONFIG" = "/usr/bin/pcap-config" \) -o \
 582                         \( "$PCAP_CONFIG" = "/usr/ccs/bin/pcap-config" \) ; then
 583                     #
 584                     # It's vendor-supplied.
 585                     #
 586                     case "$host_os" in
 587
 588                     darwin*)
 589                         #
 590                         # This is macOS or another Darwin-based OS.
 591                         #
 592                         # That means that /usr/bin/pcap-config it
 593                         # may provide -I/usr/local/include with --cflags
 594                         # and -L/usr/local/lib with --libs, rather than
 595                         # pointing to the OS-supplied library and
 596                         # Xcode-supplied headers.  Remember that, so we
 597                         # ignore those values.
 598                         #
 599                         _broken_apple_pcap_config=yes
 600                         ;;
 601
 602                     solaris*)
 603                         #
 604                         # This is Solaris 2 or later, i.e. SunOS 5.x.
 605                         #
 606                         # At least on Solaris 11; there's /usr/bin/pcap-config,
 607                         # which reports -L/usr/lib with --libs, causing
 608                         # the 32-bit libraries to be found, and there's
 609                         # /usr/bin/{64bitarch}/pcap-config, where {64bitarch}
 610                         # is a name for the 64-bit version of the instruction
 611                         # set, which reports -L /usr/lib/{64bitarch}, causing
 612                         # the 64-bit libraries to be found.
 613                         #
 614                         # So if we're building 64-bit targets, we replace
 615                         # PCAP_CONFIG with /usr/bin/{64bitarch}; we get
 616                         # {64bitarch} as the output of "isainfo -n".
 617                         #
 618                         # Are we building 32-bit or 64-bit?  Get the
 619                         # size of void *, and check that.
 620                         #
 621                         AC_CHECK_SIZEOF([void *])
 622                         if test ac_cv_sizeof_void_p -eq 8 ; then
 623                             isainfo_output=`isainfo -n`
 624                             if test ! -z "$isainfo_output" ; then
 625                                 #
 626                                 # Success - change PCAP_CONFIG.
 627                                 #
 628                                 PCAP_CONFIG=`echo $PCAP_CONFIG | sed "s;/bin/;/bin/$isainfo_output/;"`
 629                             fi
 630                         fi
 631                         ;;
 632                     esac
 633                 fi
 634                 #
 635                 # Please read section 11.6 "Shell Substitutions"
 636                 # in the autoconf manual before doing anything
 637                 # to this that involves quoting.  Especially note
 638                 # the statement "There is just no portable way to use
 639                 # double-quoted strings inside double-quoted back-quoted
 640                 # expressions (pfew!)."
 641                 #
 642                 cflags=`"$PCAP_CONFIG" --cflags`
 643                 #
 644                 # Work around macOS (and probably other Darwin) brokenness,
 645                 # by not adding /usr/local/include if it's from the broken
 646                 # Apple pcap-config.
 647                 #
 648                 if test "$_broken_apple_pcap_config" = "yes" ; then
 649                     #
 650                     # Strip -I/usr/local/include with sed.
 651                     #
 652                     cflags=`echo $cflags | sed 's;-I/usr/local/include;;'`
 653                 fi
 654                 $2="$cflags $$2"
 655                 libpcap=`"$PCAP_CONFIG" --libs`
 656                 #
 657                 # Work around macOS (and probably other Darwin) brokenness,
 658                 # by not adding /usr/local/lib if it's from the broken
 659                 # Apple pcap-config.
 660                 #
 661                 if test "$_broken_apple_pcap_config" = "yes" ; then
 662                     #
 663                     # Strip -L/usr/local/lib with sed.
 664                     #
 665                     libpcap=`echo $libpcap | sed 's;-L/usr/local/lib;;'`
 666                 fi
 667             else
 668                 #
 669                 # Not found; look for an installed pcap.
 670                 #
 671                 AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
 672                 if test $libpcap = FAIL ; then
 673                     AC_MSG_ERROR(see the INSTALL.md file for more info)
 674                 fi
 675                 dnl
 676                 dnl Some versions of Red Hat Linux put "pcap.h" in
 677                 dnl "/usr/include/pcap"; had the LBL folks done so,
 678                 dnl that would have been a good idea, but for
 679                 dnl the Red Hat folks to do so just breaks source
 680                 dnl compatibility with other systems.
 681                 dnl
 682                 dnl We work around this by assuming that, as we didn't
 683                 dnl find a local libpcap, libpcap is in /usr/lib or
 684                 dnl /usr/local/lib and that the corresponding header
 685                 dnl file is under one of those directories; if we don't
 686                 dnl find it in either of those directories, we check to
 687                 dnl see if it's in a "pcap" subdirectory of them and,
 688                 dnl if so, add that subdirectory to the "-I" list.
 689                 dnl
 690                 dnl (We now also put pcap.h in /usr/include/pcap, but we
 691                 dnl leave behind a /usr/include/pcap.h that includes it,
 692                 dnl so you can still just include <pcap.h>.)
 693                 dnl
 694                 AC_MSG_CHECKING(for extraneous pcap header directories)
 695                 if test \( ! -r /usr/local/include/pcap.h \) -a \
 696                         \( ! -r /usr/include/pcap.h \); then
 697                     if test -r /usr/local/include/pcap/pcap.h; then
 698                         d="/usr/local/include/pcap"
 699                     elif test -r /usr/include/pcap/pcap.h; then
 700                         d="/usr/include/pcap"
 701                     fi
 702                 fi
 703                 if test -z "$d" ; then
 704                     AC_MSG_RESULT(not found)
 705                 else
 706                     $2="-I$d $$2"
 707                     AC_MSG_RESULT(found -- -I$d added)
 708                 fi
 709             fi
 710         fi
 711     else
 712         #
 713         # We found a local libpcap.  Add it to the dependencies for
 714         # tcpdump.
 715         #
 716         $1=$libpcap
 717
 718         #
 719         # Look for its pcap-config script.
 720         #
 721         AC_PATH_PROG(PCAP_CONFIG, pcap-config,, $local_pcap_dir)
 722
 723         if test -n "$PCAP_CONFIG"; then
 724             #
 725             # We don't want its --cflags or --libs output, because
 726             # those presume it's installed.  For the C compiler flags,
 727             # we add the source directory for the local libpcap, so
 728             # we pick up its header files.
 729             #
 730             # We do, however, want its additional libraries, as required
 731             # when linking statically, because it makes calls to
 732             # routines in those libraries, so we'll need to link with
 733             # them, because we'll be linking statically with it.
 734             #
 735             # If it supports --static-pcap-only. use that, as we will be
 736             # linking with a static libpcap but won't be linking
 737             # statically with any of the libraries on which it depends;
 738             # those libraries might not even have static versions
 739             # installed.
 740             #
 741             # That means we need to find out the libraries on which
 742             # libpcap directly depends, so we can link with them, but we
 743             # don't need to link with the libraries on which those
 744             # libraries depend as, on all UN*Xes with which I'm
 745             # familiar, the libraries on which a shared library depends
 746             # are stored in the library and are automatically loaded by
 747             # the run-time linker, without the executable having to be
 748             # linked with those libraries.  (This allows a library to be
 749             # changed to depend on more libraries without breaking that
 750             # library's ABI.)
 751             #
 752             # The only way to test for that support is to see if the
 753             # script contains the string "static-pcap-only"; we can't
 754             # try using that flag and checking for errors, as the
 755             # versions of the script that didn't have that flag wouldn't
 756             # report or return an error for an unsupported command-line
 757             # flag.  Those older versions provided, with --static, only
 758             # the libraries on which libpcap depends, not the
 759             # dependencies of those libraries; the versions with
 760             # --static-pcap-only provide all the dependencies with
 761             # --static, for the benefit of programs that are completely
 762             # statically linked, and provide only the direct
 763             # dependencies with --static-pcap-only.
 764             #
 765             if grep -s -q "static-pcap-only" "$PCAP_CONFIG"
 766             then
 767                 static_opt="--static-pcap-only"
 768             else
 769                 static_opt="--static"
 770             fi
 771             $2="-I$local_pcap_dir $$2"
 772             additional_libs=`"$PCAP_CONFIG" $static_opt --additional-libs`
 773             libpcap="$libpcap $additional_libs"
 774         else
 775             #
 776             # It doesn't have a pcap-config script.
 777             # Make sure it has a pcap.h file.
 778             #
 779             places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
 780                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 781             places2=`ls .. | sed -e 's,/$,,' -e "s,^,../," | \
 782                 egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
 783             pcapH=FAIL
 784             if test -r $local_pcap_dir/pcap.h; then
 785                 pcapH=$local_pcap_dir
 786             else
 787                 for dir in $places $srcdir/../libpcap ../libpcap $srcdir/libpcap $places2 ; do
 788                     if test -r $dir/pcap.h ; then
 789                         pcapH=$dir
 790                     fi
 791                 done
 792             fi
 793
 794             if test $pcapH = FAIL ; then
 795                 AC_MSG_ERROR(cannot find pcap.h: see the INSTALL.md file)
 796             fi
 797
 798             #
 799             # Force the compiler to look for header files in the
 800             # directory containing pcap.h.
 801             #
 802             $2="-I$pcapH $$2"
 803         fi
 804     fi
 805
 806     if test -z "$PKG_CONFIG" -a -z "$PCAP_CONFIG"; then
 807         #
 808         # We don't have pkg-config or pcap-config; find out any additional
 809         # link flags we need.  (If we have pkg-config or pcap-config, we
 810         # assume it tells us what we need.)
 811         #
 812         case "$host_os" in
 813
 814         aix*)
 815             #
 816             # If libpcap is DLPI-based, we have to use /lib/pse.exp if
 817             # present, as we use the STREAMS routines.
 818             #
 819             # (XXX - true only if we're linking with a static libpcap?)
 820             #
 821             pseexe="/lib/pse.exp"
 822             AC_MSG_CHECKING(for $pseexe)
 823             if test -f $pseexe ; then
 824                 AC_MSG_RESULT(yes)
 825                 LIBS="$LIBS -I:$pseexe"
 826             fi
 827
 828             #
 829             # If libpcap is BPF-based, we need "-lodm" and "-lcfg", as
 830             # we use them to load the BPF module.
 831             #
 832             # (XXX - true only if we're linking with a static libpcap?)
 833             #
 834             LIBS="$LIBS -lodm -lcfg"
 835             ;;
 836
 837         solaris*)
 838             # libdlpi is needed for Solaris 11 and later.
 839             AC_CHECK_LIB(dlpi, dlpi_walk, LIBS="$LIBS -ldlpi" LDFLAGS="-L/lib $LDFLAGS", ,-L/lib)
 840             ;;
 841         esac
 842     fi
 843
 844     LIBS="$libpcap $LIBS"
 845
 846     dnl
 847     dnl Check for "pcap_loop()", to make sure we found a working
 848     dnl libpcap and have all the right other libraries with which
 849     dnl to link.  (Otherwise, the checks below will fail, not
 850     dnl because the routines are missing from the library, but
 851     dnl because we aren't linking properly with libpcap, and
 852     dnl that will cause confusing errors at build time.)
 853     dnl
 854     AC_CHECK_FUNC(pcap_loop,,
 855     [
 856         AC_MSG_ERROR(
 857 [This is a bug, please follow the guidelines in CONTRIBUTING.md and include the
 858 config.log file in your report.  If you have downloaded libpcap from
 859 tcpdump.org, and built it yourself, please also include the config.log
 860 file from the libpcap source directory, the Makefile from the libpcap
 861 source directory, and the output of the make process for libpcap, as
 862 this could be a problem with the libpcap that was built, and we will
 863 not be able to determine why this is happening, and thus will not be
 864 able to fix it, without that information, as we have not been able to
 865 reproduce this problem ourselves.])
 866     ])
 867 ])
 868
 869 dnl
 870 dnl Check whether a given format can be used to print 64-bit integers
 871 dnl
 872 AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,
 873   [
 874     AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])
 875     AC_RUN_IFELSE(
 876       [
 877         AC_LANG_SOURCE(
 878           [[
 879 #           ifdef HAVE_INTTYPES_H
 880             #include <inttypes.h>
 881 #           endif
 882             #include <stdio.h>
 883             #include <sys/types.h>
 884
 885             main()
 886             {
 887               uint64_t t = 1;
 888               char strbuf[16+1];
 889               sprintf(strbuf, "%016$1x", t << 32);
 890               if (strcmp(strbuf, "0000000100000000") == 0)
 891                 exit(0);
 892               else
 893                 exit(1);
 894             }
 895           ]])
 896       ],
 897       [
 898         AC_DEFINE(PRId64, "$1d", [define if the platform doesn't define PRId64])
 899         AC_DEFINE(PRIo64, "$1o", [define if the platform doesn't define PRIo64])
 900         AC_DEFINE(PRIx64, "$1x", [define if the platform doesn't define PRIu64])
 901         AC_DEFINE(PRIu64, "$1u", [define if the platform doesn't define PRIx64])
 902         AC_MSG_RESULT(yes)
 903       ],
 904       [
 905         AC_MSG_RESULT(no)
 906         $2
 907       ])
 908   ])
 909
 910 dnl
 911 dnl If the file .devel exists:
 912 dnl     Add some warning flags if the compiler supports them
 913 dnl     If an os prototype include exists, symlink os-proto.h to it
 914 dnl
 915 dnl usage:
 916 dnl
 917 dnl     AC_LBL_DEVEL(copt)
 918 dnl
 919 dnl results:
 920 dnl
 921 dnl     $1 (copt appended)
 922 dnl     HAVE_OS_PROTO_H (defined)
 923 dnl     os-proto.h (symlinked)
 924 dnl
 925 AC_DEFUN(AC_LBL_DEVEL,
 926     [rm -f os-proto.h
 927     if test "${LBL_CFLAGS+set}" = set; then
 928             $1="$$1 ${LBL_CFLAGS}"
 929     fi
 930     if test -f .devel ; then
 931             #
 932             # Skip all the warning option stuff on some compilers.
 933             #
 934             if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then
 935                     AC_LBL_CHECK_COMPILER_OPT($1, -W)
 936                     AC_LBL_CHECK_COMPILER_OPT($1, -Wall)
 937                     AC_LBL_CHECK_COMPILER_OPT($1, -Wassign-enum)
 938                     AC_LBL_CHECK_COMPILER_OPT($1, -Wcast-qual)
 939                     AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)
 940                     AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-variable-declarations)
 941                     AC_LBL_CHECK_COMPILER_OPT($1, -Wold-style-definition)
 942                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpedantic)
 943                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-arith)
 944                     AC_LBL_CHECK_COMPILER_OPT($1, -Wpointer-sign)
 945                     AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)
 946                     AC_LBL_CHECK_COMPILER_OPT($1, -Wsign-compare)
 947                     AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)
 948                     AC_LBL_CHECK_COMPILER_OPT($1, -Wunreachable-code-return)
 949                     AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused)
 950                     AC_LBL_CHECK_COMPILER_OPT($1, -Wwrite-strings)
 951             fi
 952             AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()
 953             #
 954             # We used to set -n32 for IRIX 6 when not using GCC (presumed
 955             # to mean that we're using MIPS C or MIPSpro C); it specified
 956             # the "new" faster 32-bit ABI, introduced in IRIX 6.2.  I'm
 957             # not sure why that would be something to do *only* with a
 958             # .devel file; why should the ABI for which we produce code
 959             # depend on .devel?
 960             #
 961             os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
 962             name="lbl/os-$os.h"
 963             if test -f $name ; then
 964                     ln -s $name os-proto.h
 965                     AC_DEFINE(HAVE_OS_PROTO_H, 1,
 966                         [if there's an os_proto.h for this platform, to use additional prototypes])
 967             else
 968                     AC_MSG_WARN(can't find $name)
 969             fi
 970     fi])
 971
 972 dnl
 973 dnl Improved version of AC_CHECK_LIB
 974 dnl
 975 dnl Thanks to John Hawkinson (jhawk@mit.edu)
 976 dnl
 977 dnl usage:
 978 dnl
 979 dnl     AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
 980 dnl         ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
 981 dnl
 982 dnl results:
 983 dnl
 984 dnl     LIBS
 985 dnl
 986 dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
 987 dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
 988 dnl We keep it around for reference purposes in case it's ever
 989 dnl useful in the future.
 990 dnl
 991
 992 define(AC_LBL_CHECK_LIB,
 993 [AC_MSG_CHECKING([for $2 in -l$1])
 994 dnl Use a cache variable name containing the library, function
 995 dnl name, and extra libraries to link with, because the test really is
 996 dnl for library $1 defining function $2, when linked with potinal
 997 dnl library $5, not just for library $1.  Separate tests with the same
 998 dnl $1 and different $2's or $5's may have different results.
 999 ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
1000 AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
1001 [ac_save_LIBS="$LIBS"
1002 LIBS="-l$1 $5 $LIBS"
1003 AC_TRY_LINK(dnl
1004 ifelse([$2], [main], , dnl Avoid conflicting decl of main.
1005 [/* Override any gcc2 internal prototype to avoid an error.  */
1006 ]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
1007 extern "C"
1008 #endif
1009 ])dnl
1010 [/* We use char because int might match the return type of a gcc2
1011     builtin and then its argument prototype would still apply.  */
1012 char $2();
1013 ]),
1014             [$2()],
1015             eval "ac_cv_lbl_lib_$ac_lib_var=yes",
1016             eval "ac_cv_lbl_lib_$ac_lib_var=no")
1017 LIBS="$ac_save_LIBS"
1018 ])dnl
1019 if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
1020   AC_MSG_RESULT(yes)
1021   ifelse([$3], ,
1022 [changequote(, )dnl
1023   ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
1024     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
1025 changequote([, ])dnl
1026   AC_DEFINE_UNQUOTED($ac_tr_lib)
1027   LIBS="-l$1 $LIBS"
1028 ], [$3])
1029 else
1030   AC_MSG_RESULT(no)
1031 ifelse([$4], , , [$4
1032 ])dnl
1033 fi
1034 ])
1035
1036 dnl
1037 dnl AC_LBL_LIBRARY_NET
1038 dnl
1039 dnl This test is for network applications that need socket() and
1040 dnl gethostbyaddr() -ish functions.  Under Solaris, those applications
1041 dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
1042 dnl with "-lnsl" but should *not* link with "-lsocket" because
1043 dnl libsocket.a breaks a number of things (for instance:
1044 dnl gethostbyaddr() under IRIX 5.2, and snoop sockets under most
1045 dnl versions of IRIX).
1046 dnl
1047 dnl Unfortunately, many application developers are not aware of this,
1048 dnl and mistakenly write tests that cause -lsocket to be used under
1049 dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
1050 dnl under operating systems where neither are necessary (or useful),
1051 dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
1052 dnl
1053 dnl This test exists so that every application developer does not test
1054 dnl this in a different, and subtly broken fashion.
1055
1056 dnl It has been argued that this test should be broken up into two
1057 dnl separate tests, one for the resolver libraries, and one for the
1058 dnl libraries necessary for using Sockets API. Unfortunately, the two
1059 dnl are carefully intertwined and allowing the autoconf user to use
1060 dnl them independently potentially results in unfortunate ordering
1061 dnl dependencies -- as such, such component macros would have to
1062 dnl carefully use indirection and be aware if the other components were
1063 dnl executed. Since other autoconf macros do not go to this trouble,
1064 dnl and almost no applications use sockets without the resolver, this
1065 dnl complexity has not been implemented.
1066 dnl
1067 dnl The check for libresolv is in case you are attempting to link
1068 dnl statically and happen to have a libresolv.a lying around (and no
1069 dnl libnsl.a).
1070 dnl
1071 AC_DEFUN(AC_LBL_LIBRARY_NET, [
1072     # Most operating systems have gethostbyaddr() in the default searched
1073     # libraries (i.e. libc):
1074     # Some OSes (eg. Solaris) place it in libnsl
1075     # Some strange OSes (SINIX) have it in libsocket:
1076     AC_SEARCH_LIBS(gethostbyaddr, network nsl socket resolv)
1077     # Unfortunately libsocket sometimes depends on libnsl and
1078     # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
1079     if test "$ac_cv_search_gethostbyaddr" = "no"
1080     then
1081         AC_CHECK_LIB(socket, gethostbyaddr,
1082                      LIBS="-lsocket -lnsl $LIBS", , -lnsl)
1083     fi
1084     AC_SEARCH_LIBS(socket, socket, ,
1085         AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
1086     # DLPI needs putmsg under HPUX so test for -lstr while we're at it
1087     AC_SEARCH_LIBS(putmsg, str)
1088     ])