The Tcpdump Group git mirrors - tcpdump/blob - configure.ac

   1 dnl Copyright (c) 1994, 1995, 1996, 1997
   2 dnl     The Regents of the University of California.  All rights reserved.
   3 dnl
   4 dnl Process this file with autoconf to produce a configure script.
   5 dnl
   6
   7 #
   8 # See
   9 #
  10 #       https://ftp.gnu.org/gnu/config/README
  11 #
  12 # for the URLs to use to fetch new versions of config.guess and
  13 # config.sub.
  14 #
  15
  16 AC_PREREQ([2.69])
  17 AC_INIT([tcpdump],[m4_esyscmd_s(cat VERSION)])
  18 AC_CONFIG_SRCDIR(tcpdump.c)
  19
  20 AC_CANONICAL_HOST
  21
  22 AC_LBL_C_INIT_BEFORE_CC(V_INCLS)
  23 #
  24 # Try to enable as many C99 features as we can.
  25 # At minimum, we want C++/C99-style // comments.
  26 #
  27 AC_PROG_CC_C99
  28 if test "$ac_cv_prog_cc_c99" = "no"; then
  29         AC_MSG_WARN([The C compiler does not support C99; there may be compiler errors])
  30 fi
  31 AC_LBL_C_INIT(V_CCOPT, V_INCLS)
  32 AC_LBL_C_INLINE
  33
  34 AC_CHECK_HEADERS(fcntl.h rpc/rpc.h rpc/rpcent.h net/if.h)
  35 #
  36 # Get the size of a void *, to know whether this is a 32-bit or 64-bit build.
  37 #
  38 AC_CHECK_SIZEOF([void *])
  39
  40 #
  41 # Get the size of a time_t, to know whether it's 32-bit or 64-bit.
  42 #
  43 AC_CHECK_SIZEOF([time_t],,[#include <time.h>])
  44
  45 case "$host_os" in
  46
  47 darwin*)
  48         AC_ARG_ENABLE(universal,
  49         AS_HELP_STRING([--disable-universal],[don't build universal on macOS]))
  50         if test "$enable_universal" != "no"; then
  51                 case "$host_os" in
  52
  53                 darwin9.*)
  54                         #
  55                         # Leopard.  Build for x86 and 32-bit PowerPC, with
  56                         # x86 first.  (That's what Apple does.)
  57                         #
  58                         V_CCOPT="$V_CCOPT -arch i386 -arch ppc"
  59                         LDFLAGS="$LDFLAGS -arch i386 -arch ppc"
  60                         ;;
  61
  62                 darwin10.*)
  63                         #
  64                         # Snow Leopard.  Build for x86-64 and x86, with
  65                         # x86-64 first.  (That's what Apple does.)
  66                         #
  67                         V_CCOPT="$V_CCOPT -arch x86_64 -arch i386"
  68                         LDFLAGS="$LDFLAGS -arch x86_64 -arch i386"
  69                         ;;
  70                 esac
  71         fi
  72         ;;
  73 esac
  74
  75
  76 AC_ARG_WITH([smi],
  77    [AS_HELP_STRING([--with-smi],
  78      [link with libsmi (allows to load MIBs on the fly to decode SNMP packets) [default=yes, if available]])],
  79    [],
  80    [with_smi=yes])
  81
  82 if test "x$with_smi" != "xno" ; then
  83         AC_CHECK_HEADER(smi.h,
  84         [
  85                 #
  86                 # OK, we found smi.h.  Do we have libsmi with smiInit?
  87                 #
  88                 AC_CHECK_LIB(smi, smiInit,
  89                 [
  90                         #
  91                         # OK, we have libsmi with smiInit.  Can we use it?
  92                         #
  93                         AC_MSG_CHECKING([whether to enable libsmi])
  94                         savedlibs="$LIBS"
  95                         LIBS="-lsmi $LIBS"
  96                         AC_RUN_IFELSE([AC_LANG_SOURCE([[
  97 /* libsmi available check */
  98 #include <stdio.h>
  99 #include <stdlib.h>
 100 #include <string.h>
 101 #include <smi.h>
 102 int main()
 103 {
 104   int current, revision, age, n;
 105   const int required = 2;
 106   if (smiInit(""))
 107     exit(1);
 108   if (strcmp(SMI_LIBRARY_VERSION, smi_library_version))
 109     exit(2);
 110   n = sscanf(smi_library_version, "%d:%d:%d", &current, &revision, &age);
 111   if (n != 3)
 112     exit(3);
 113   if (required < current - age || required > current)
 114     exit(4);
 115   exit(0);
 116 }
 117                                 ]])
 118                                 ],
 119                                 [
 120                                         AC_MSG_RESULT(yes)
 121                                         AC_DEFINE(USE_LIBSMI, 1,
 122                                             [Define if you enable support for libsmi])
 123                                 ],
 124                                 [
 125                                         dnl autoconf documentation says that
 126                                         dnl $? contains the exit value.
 127                                         dnl reality is that it does not.
 128                                         dnl We leave this in just in case
 129                                         dnl autoconf ever comes back to
 130                                         dnl match the documentation.
 131                                         case $? in
 132                                           1) AC_MSG_RESULT(no - smiInit failed) ;;
 133                                           2) AC_MSG_RESULT(no - header/library version mismatch) ;;
 134                                           3) AC_MSG_RESULT(no - can't determine library version) ;;
 135                                           4) AC_MSG_RESULT(no - too old) ;;
 136                                           *) AC_MSG_RESULT(no) ;;
 137                                         esac
 138                                         LIBS="$savedlibs"
 139                                 ],
 140                                 [
 141                                         AC_MSG_RESULT(not when cross-compiling)
 142                                         LIBS="$savedlibs"
 143                                 ]
 144                         )
 145                 ])
 146         ])
 147 fi
 148
 149 AC_MSG_CHECKING([whether to enable the instrument functions code])
 150 AC_ARG_ENABLE([instrument-functions],
 151    [AS_HELP_STRING([--enable-instrument-functions],
 152      [enable instrument functions code [default=no]])],
 153    [],
 154    [enableval=no])
 155 case "$enableval" in
 156 yes)    AC_MSG_RESULT(yes)
 157         AC_CHECK_LIB([bfd], [bfd_init],
 158             [true],
 159             [AC_MSG_ERROR(
 160                [--enable-instrument-functions was given, but test for library libbfd failed. Please install the 'binutils-dev' package.])],
 161             [])
 162         AC_DEFINE(ENABLE_INSTRUMENT_FUNCTIONS, 1,
 163             [define if you want to build the instrument functions code])
 164         LOCALSRC="$LOCALSRC instrument-functions.c"
 165         # Add '-finstrument-functions' instrumentation option to generate
 166         # instrumentation calls for entry and exit to functions.
 167         # Try to avoid Address Space Layout Randomization (ALSR).
 168         CFLAGS="$CFLAGS -O0 -ggdb -finstrument-functions -fno-stack-protector -fno-pic"
 169         LDFLAGS="$LDFLAGS -O0 -ggdb -fno-stack-protector -no-pie"
 170         LIBS="$LIBS -lbfd"
 171         ;;
 172 *)      AC_MSG_RESULT(no)
 173         ;;
 174 esac
 175
 176 AC_MSG_CHECKING([whether to enable the possibly-buggy SMB printer])
 177 AC_ARG_ENABLE([smb],
 178    [AS_HELP_STRING([--enable-smb],
 179      [enable possibly-buggy SMB printer [default=no]])],
 180    [],
 181    [enableval=no])
 182 case "$enableval" in
 183 yes)    AC_MSG_RESULT(yes)
 184         AC_DEFINE(ENABLE_SMB, 1,
 185             [define if you want to build the possibly-buggy SMB printer])
 186         LOCALSRC="print-smb.c smbutil.c $LOCALSRC"
 187         ;;
 188 *)      AC_MSG_RESULT(no)
 189         ;;
 190 esac
 191
 192 AC_MSG_CHECKING([whether to drop root privileges by default])
 193 AC_ARG_WITH(
 194         [user],
 195         [AS_HELP_STRING([--with-user=USERNAME],
 196                 [drop privileges by default to USERNAME]
 197         )],
 198         [],
 199         [withval=no])
 200 AS_CASE(["$withval"],
 201         [no], [AC_MSG_RESULT(no)],
 202         [''|yes], [AC_MSG_ERROR([--with-user requires a username])],
 203         [
 204                 AC_DEFINE_UNQUOTED(WITH_USER, "$withval",
 205                     [define if should drop privileges by default])
 206                 AC_MSG_RESULT([yes, to user "$withval"])
 207         ]
 208 )
 209
 210 AC_MSG_CHECKING([whether to chroot])
 211 AC_ARG_WITH(
 212         [chroot],
 213         [AS_HELP_STRING([--with-chroot=DIRECTORY],
 214                 [when dropping privileges, chroot to DIRECTORY]
 215         )],
 216         [],
 217         [withval=no]
 218 )
 219 AS_CASE(["$withval"],
 220         [no], [AC_MSG_RESULT(no)],
 221         [''|yes], [AC_MSG_ERROR([--with-chroot requires a directory])],
 222         [
 223                 AC_DEFINE_UNQUOTED(WITH_CHROOT, "$withval",
 224                     [define if should chroot when dropping privileges])
 225                 AC_MSG_RESULT([yes, to directory "$withval"])
 226         ]
 227 )
 228
 229 AC_ARG_WITH(sandbox-capsicum,
 230         AS_HELP_STRING([--with-sandbox-capsicum],
 231                        [use Capsicum security functions @<:@default=yes, if available@:>@]))
 232 #
 233 # Check whether various functions are available.  If any are, set
 234 # ac_lbl_capsicum_function_seen to yes; if any are not, set
 235 # ac_lbl_capsicum_function_not_seen to yes.
 236 #
 237 # We don't check cap_rights_init(), as it's a macro, wrapping another
 238 # function, in at least some versions of FreeBSD, and AC_CHECK_FUNCS()
 239 # doesn't handle that.
 240 #
 241 # All of the ones we check for must be available in order to enable
 242 # capsicum sandboxing.
 243 #
 244 # XXX - do we need to check for all of them, or are there some that, if
 245 # present, imply others are present?
 246 #
 247 if test -z "$with_sandbox_capsicum" || test "$with_sandbox_capsicum" != "no" ; then
 248         #
 249         # First, make sure we have the required header.
 250         #
 251         AC_CHECK_HEADER(sys/capsicum.h,
 252         [
 253                 #
 254                 # We do; now make sure we have the required functions.
 255                 #
 256                 AC_CHECK_FUNCS(cap_enter cap_rights_limit cap_ioctls_limit openat,
 257                     ac_lbl_capsicum_function_seen=yes,
 258                     ac_lbl_capsicum_function_not_seen=yes)
 259         ])
 260         AC_CHECK_LIB(casper, cap_init, LIBS="$LIBS -lcasper")
 261         AC_CHECK_LIB(cap_dns, cap_gethostbyaddr, LIBS="$LIBS -lcap_dns")
 262 fi
 263 AC_MSG_CHECKING([whether to sandbox using capsicum])
 264 if test "x$ac_lbl_capsicum_function_seen" = "xyes" -a "x$ac_lbl_capsicum_function_not_seen" != "xyes"; then
 265         AC_DEFINE(HAVE_CAPSICUM, 1, [capsicum support available])
 266         AC_MSG_RESULT(yes)
 267 else
 268         AC_MSG_RESULT(no)
 269 fi
 270 AC_MSG_CHECKING([whether to sandbox using Casper library])
 271 if test "x$ac_cv_lib_casper_cap_init" = "xyes" -a "x$ac_cv_lib_cap_dns_cap_gethostbyaddr" = "xyes"; then
 272         AC_DEFINE(HAVE_CASPER, 1, [Casper support available])
 273         AC_MSG_RESULT(yes)
 274 else
 275         AC_MSG_RESULT(no)
 276 fi
 277
 278 #
 279 # We must check this before checking whether to check the OS's IPv6,
 280 # support because, on some platforms (such as SunOS 5.x), the test
 281 # program requires the extra networking libraries.
 282 #
 283 AC_LBL_LIBRARY_NET
 284
 285 #
 286 # Check whether AF_INET6 and struct in6_addr are defined.
 287 # If they aren't both defined, we don't have sufficient OS
 288 # support for IPv6, so we don't look for IPv6 support libraries,
 289 # and we define AF_INET6 and struct in6_addr ourselves.
 290 #
 291 AC_MSG_CHECKING([whether the operating system supports IPv6])
 292 AC_COMPILE_IFELSE(
 293     [
 294       AC_LANG_SOURCE(
 295         [[
 296 #include <string.h>
 297 /* AF_INET6 available check */
 298 #include <sys/types.h>
 299 #ifdef _WIN32
 300 #include <ws2tcpip.h>
 301 #else
 302 #include <sys/socket.h>
 303 #include <netinet/in.h>
 304 #endif
 305 #ifdef AF_INET6
 306 void
 307 foo(struct in6_addr *addr)
 308 {
 309  memset(addr, 0, sizeof (struct in6_addr));
 310 }
 311 #else
 312 #error "AF_INET6 not defined"
 313 #endif
 314         ]])
 315     ],
 316     [
 317         AC_MSG_RESULT(yes)
 318         AC_DEFINE(HAVE_OS_IPV6_SUPPORT, 1,
 319             [define if the OS provides AF_INET6 and struct in6_addr])
 320         ipv6=yes
 321     ],
 322     [
 323         AC_MSG_RESULT(no)
 324         ipv6=no
 325     ]
 326 )
 327
 328 ipv6type=unknown
 329 ipv6lib=none
 330 ipv6trylibc=no
 331
 332 if test "$ipv6" = "yes"; then
 333         AC_MSG_CHECKING([ipv6 stack type])
 334         for i in inria kame linux-glibc linux-libinet6 toshiba v6d zeta; do
 335                 case $i in
 336                 inria)
 337                         dnl http://www.kame.net/
 338                         AC_EGREP_CPP(yes,
 339 [#include <netinet/in.h>
 340 #ifdef IPV6_INRIA_VERSION
 341 yes
 342 #endif],
 343                                 [ipv6type=$i])
 344                         ;;
 345                 kame)
 346                         dnl http://www.kame.net/
 347                         AC_EGREP_CPP(yes,
 348 [#include <netinet/in.h>
 349 #ifdef __KAME__
 350 yes
 351 #endif],
 352                                 [ipv6type=$i;
 353                                 ipv6lib=inet6;
 354                                 ipv6libdir=/usr/local/v6/lib;
 355                                 ipv6trylibc=yes])
 356                         ;;
 357                 linux-glibc)
 358                         dnl http://www.v6.linux.or.jp/
 359                         AC_EGREP_CPP(yes,
 360 [#include <features.h>
 361 #if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1
 362 yes
 363 #endif],
 364                                 [ipv6type=$i])
 365                         ;;
 366                 linux-libinet6)
 367                         dnl http://www.v6.linux.or.jp/
 368                         dnl
 369                         dnl This also matches Solaris 8 and Tru64 UNIX 5.1,
 370                         dnl and possibly other versions of those OSes
 371                         dnl
 372                         if test -d /usr/inet6 -o -f /usr/include/netinet/ip6.h; then
 373                                 ipv6type=$i
 374                                 ipv6lib=inet6
 375                                 ipv6libdir=/usr/inet6/lib
 376                                 ipv6trylibc=yes;
 377                                 CFLAGS="-I/usr/inet6/include $CFLAGS"
 378                         fi
 379                         ;;
 380                 toshiba)
 381                         AC_EGREP_CPP(yes,
 382 [#include <sys/param.h>
 383 #ifdef _TOSHIBA_INET6
 384 yes
 385 #endif],
 386                                 [ipv6type=$i;
 387                                 ipv6lib=inet6;
 388                                 ipv6libdir=/usr/local/v6/lib])
 389                         ;;
 390                 v6d)
 391                         AC_EGREP_CPP(yes,
 392 [#include </usr/local/v6/include/sys/v6config.h>
 393 #ifdef __V6D__
 394 yes
 395 #endif],
 396                                 [ipv6type=$i;
 397                                 ipv6lib=v6;
 398                                 ipv6libdir=/usr/local/v6/lib;
 399                                 CFLAGS="-I/usr/local/v6/include $CFLAGS"])
 400                         ;;
 401                 zeta)
 402                         AC_EGREP_CPP(yes,
 403 [#include <sys/param.h>
 404 #ifdef _ZETA_MINAMI_INET6
 405 yes
 406 #endif],
 407                                 [ipv6type=$i;
 408                                 ipv6lib=inet6;
 409                                 ipv6libdir=/usr/local/v6/lib])
 410                         ;;
 411                 esac
 412                 if test "$ipv6type" != "unknown"; then
 413                         break
 414                 fi
 415         done
 416         AC_MSG_RESULT($ipv6type)
 417 fi
 418
 419 if test "$ipv6" = "yes" -a "$ipv6lib" != "none"; then
 420         if test -d $ipv6libdir -a -f $ipv6libdir/lib$ipv6lib.a; then
 421                 LIBS="-L$ipv6libdir -l$ipv6lib $LIBS"
 422                 echo "You have $ipv6lib library, using it"
 423         else
 424                 if test "$ipv6trylibc" = "yes"; then
 425                         echo "You do not have $ipv6lib library, using libc"
 426                 else
 427                         echo 'Fatal: no $ipv6lib library found.  cannot continue.'
 428                         echo "You need to fetch lib$ipv6lib.a from appropriate"
 429                         echo 'ipv6 kit and compile beforehand.'
 430                         exit 1
 431                 fi
 432         fi
 433 fi
 434
 435 AC_REPLACE_FUNCS(strlcat strlcpy strdup strsep getservent getopt_long)
 436 AC_CHECK_FUNCS(fork vfork)
 437 AC_CHECK_FUNCS(setlinebuf)
 438
 439 #
 440 # Make sure we have snprintf(); we require it.
 441 #
 442 AC_CHECK_FUNC(snprintf,,
 443     AC_MSG_ERROR([snprintf() is required but wasn't found]))
 444
 445 #
 446 # It became apparent at some point that using a suitable C99 compiler does not
 447 # automatically mean snprintf(3) implementation in the libc supports all the
 448 # modifiers and specifiers used in the project, so let's test that before the
 449 # build, not after.
 450 #
 451 # Testing the sizeof_t length modifier takes making an snprintf() call and
 452 # comparing the actual result with the expected result.  If this fails, it will
 453 # most likely happen at run time, not compile time.
 454 #
 455 # Testing the 64-bit conversion specifiers in addition to that requires the
 456 # <inttypes.h> header to be present and the macros to be defined, so if this
 457 # fails, it will more likely happen at compile time.
 458 #
 459 AC_MSG_CHECKING([whether snprintf is suitable])
 460 AC_RUN_IFELSE(
 461     [
 462         AC_LANG_SOURCE([[
 463 #include <stdio.h>
 464 #include <string.h>
 465 #include <inttypes.h>
 466 #include <sys/types.h>
 467
 468 int main()
 469 {
 470   char buf[100];
 471   uint64_t t = (uint64_t)1 << 32;
 472
 473   snprintf(buf, sizeof(buf), "%zu", sizeof(buf));
 474   if (strncmp(buf, "100", sizeof(buf)))
 475     return 1;
 476
 477   snprintf(buf, sizeof(buf), "%zd", -sizeof(buf));
 478   if (strncmp(buf, "-100", sizeof(buf)))
 479     return 2;
 480
 481   snprintf(buf, sizeof(buf), "%" PRId64, -t);
 482   if (strncmp(buf, "-4294967296", sizeof(buf)))
 483     return 3;
 484
 485   snprintf(buf, sizeof(buf), "0o%" PRIo64, t);
 486   if (strncmp(buf, "0o40000000000", sizeof(buf)))
 487     return 4;
 488
 489   snprintf(buf, sizeof(buf), "0x%" PRIx64, t);
 490   if (strncmp(buf, "0x100000000", sizeof(buf)))
 491     return 5;
 492
 493   snprintf(buf, sizeof(buf), "%" PRIu64, t);
 494   if (strncmp(buf, "4294967296", sizeof(buf)))
 495     return 6;
 496
 497   return 0;
 498 }
 499         ]])
 500     ],
 501     [
 502         AC_MSG_RESULT(yes)
 503     ],
 504     [
 505         AC_MSG_RESULT(no)
 506         AC_MSG_ERROR(
 507 [The snprintf(3) implementation in this libc is not suitable,
 508 tcpdump would not work correctly even if it managed to compile.])
 509     ],
 510     [
 511         AC_MSG_RESULT(not while cross-compiling)
 512     ]
 513 )
 514
 515 AC_CHECK_LIB(rpc, main)         dnl It's unclear why we might need -lrpc
 516
 517 dnl Some platforms may need -lnsl for getrpcbynumber.
 518 AC_SEARCH_LIBS(getrpcbynumber, nsl,
 519     AC_DEFINE(HAVE_GETRPCBYNUMBER, 1, [define if you have getrpcbynumber()]))
 520
 521 AC_LBL_LIBPCAP(V_PCAPDEP, V_INCLS)
 522
 523 #
 524 # Check for these after AC_LBL_LIBPCAP, so we link with the appropriate
 525 # libraries (e.g., "-lsocket -lnsl" on Solaris).
 526 #
 527 # You are in a twisty little maze of UN*Xes, all different.
 528 # Some might not have ether_ntohost().
 529 # Some might have it and declare it in <net/ethernet.h>.
 530 # Some might have it and declare it in <netinet/ether.h>
 531 # Some might have it and declare it in <sys/ethernet.h>.
 532 # Some might have it and declare it in <arpa/inet.h>.
 533 # Some might have it and declare it in <netinet/if_ether.h>.
 534 # Some might have it and not declare it in any header file.
 535 #
 536 # Before you is a C compiler.
 537 #
 538 AC_CHECK_FUNCS(ether_ntohost, [
 539     AC_CACHE_CHECK(for buggy ether_ntohost, ac_cv_buggy_ether_ntohost, [
 540         AC_RUN_IFELSE([AC_LANG_SOURCE([[
 541                 #include <netdb.h>
 542                 #include <netinet/ether.h>
 543                 #include <stdlib.h>
 544                 #include <sys/types.h>
 545                 #include <sys/param.h>
 546                 #include <sys/socket.h>
 547
 548                 int
 549                 main(int argc, char **argv)
 550                 {
 551                         u_char ea[6] = { 0xff, 0xff, 0xff, 0xff, 0xff };
 552                         char name[MAXHOSTNAMELEN];
 553
 554                         ether_ntohost(name, (struct ether_addr *)ea);
 555                         exit(0);
 556                 }
 557         ]])
 558         ], [ac_cv_buggy_ether_ntohost=no],
 559            [ac_cv_buggy_ether_ntohost=yes],
 560            [ac_cv_buggy_ether_ntohost="not while cross-compiling"])])
 561     if test "$ac_cv_buggy_ether_ntohost" = "no"; then
 562         AC_DEFINE(USE_ETHER_NTOHOST, 1,
 563             [define if you have ether_ntohost() and it works])
 564     fi
 565 ])
 566 if test "$ac_cv_func_ether_ntohost" = yes -a \
 567     "$ac_cv_buggy_ether_ntohost" = "no"; then
 568         #
 569         # OK, we have ether_ntohost().  Is it declared in <net/ethernet.h>?
 570         #
 571         # This test fails if we don't have <net/ethernet.h> or if we do
 572         # but it doesn't declare ether_ntohost().
 573         #
 574         AC_CHECK_DECL(ether_ntohost,
 575             [
 576                 AC_DEFINE(NET_ETHERNET_H_DECLARES_ETHER_NTOHOST,,
 577                     [Define to 1 if net/ethernet.h declares `ether_ntohost'])
 578             ],,
 579             [
 580 #include <net/ethernet.h>
 581             ])
 582         #
 583         # Did that succeed?
 584         #
 585         if test "$ac_cv_have_decl_ether_ntohost" != yes; then
 586                 #
 587                 # No, how about <netinet/ether.h>, as on Linux?
 588                 #
 589                 # This test fails if we don't have <netinet/ether.h>
 590                 # or if we do but it doesn't declare ether_ntohost().
 591                 #
 592                 # Unset ac_cv_have_decl_ether_ntohost so we don't
 593                 # treat the previous failure as a cached value and
 594                 # suppress the next test.
 595                 #
 596                 unset ac_cv_have_decl_ether_ntohost
 597                 AC_CHECK_DECL(ether_ntohost,
 598                     [
 599                         AC_DEFINE(NETINET_ETHER_H_DECLARES_ETHER_NTOHOST,,
 600                             [Define to 1 if netinet/ether.h declares `ether_ntohost'])
 601                     ],,
 602                     [
 603 #include <netinet/ether.h>
 604                     ])
 605         fi
 606         #
 607         # Did that succeed?
 608         #
 609         if test "$ac_cv_have_decl_ether_ntohost" != yes; then
 610                 #
 611                 # No, how about <sys/ethernet.h>, as on Solaris 10
 612                 # and later?
 613                 #
 614                 # This test fails if we don't have <sys/ethernet.h>
 615                 # or if we do but it doesn't declare ether_ntohost().
 616                 #
 617                 # Unset ac_cv_have_decl_ether_ntohost so we don't
 618                 # treat the previous failure as a cached value and
 619                 # suppress the next test.
 620                 #
 621                 unset ac_cv_have_decl_ether_ntohost
 622                 AC_CHECK_DECL(ether_ntohost,
 623                     [
 624                         AC_DEFINE(SYS_ETHERNET_H_DECLARES_ETHER_NTOHOST,,
 625                             [Define to 1 if sys/ethernet.h declares `ether_ntohost'])
 626                     ],,
 627                     [
 628 #include <sys/ethernet.h>
 629                     ])
 630         fi
 631         #
 632         # Did that succeed?
 633         #
 634         if test "$ac_cv_have_decl_ether_ntohost" != yes; then
 635                 #
 636                 # No, how about <arpa/inet.h>, as in AIX?
 637                 #
 638                 # This test fails if we don't have <arpa/inet.h>
 639                 # (if we have ether_ntohost(), we should have
 640                 # networking, and if we have networking, we should
 641                 # have <arpa/inet.h>) or if we do but it doesn't
 642                 # declare ether_ntohost().
 643                 #
 644                 # Unset ac_cv_have_decl_ether_ntohost so we don't
 645                 # treat the previous failure as a cached value and
 646                 # suppress the next test.
 647                 #
 648                 unset ac_cv_have_decl_ether_ntohost
 649                 AC_CHECK_DECL(ether_ntohost,
 650                     [
 651                         AC_DEFINE(ARPA_INET_H_DECLARES_ETHER_NTOHOST,,
 652                             [Define to 1 if arpa/inet.h declares `ether_ntohost'])
 653                     ],,
 654                     [
 655 #include <arpa/inet.h>
 656                     ])
 657         fi
 658         #
 659         # Did that succeed?
 660         #
 661         if test "$ac_cv_have_decl_ether_ntohost" != yes; then
 662                 #
 663                 # No, how about <netinet/if_ether.h>?
 664                 # On some platforms, it requires <net/if.h> and
 665                 # <netinet/in.h>, and we always include it with
 666                 # both of them, so test it with both of them.
 667                 #
 668                 # This test fails if we don't have <netinet/if_ether.h>
 669                 # and the headers we include before it, or if we do but
 670                 # <netinet/if_ether.h> doesn't declare ether_hostton().
 671                 #
 672                 # Unset ac_cv_have_decl_ether_ntohost so we don't
 673                 # treat the previous failure as a cached value and
 674                 # suppress the next test.
 675                 #
 676                 unset ac_cv_have_decl_ether_ntohost
 677                 AC_CHECK_DECL(ether_ntohost,
 678                     [
 679                         AC_DEFINE(NETINET_IF_ETHER_H_DECLARES_ETHER_NTOHOST,,
 680                             [Define to 1 if netinet/if_ether.h declares `ether_ntohost'])
 681                     ],,
 682                     [
 683 #include <sys/types.h>
 684 #include <sys/socket.h>
 685 #include <net/if.h>
 686 #include <netinet/in.h>
 687 #include <netinet/if_ether.h>
 688                     ])
 689         fi
 690         #
 691         # After all that, is ether_ntohost() declared?
 692         #
 693         if test "$ac_cv_have_decl_ether_ntohost" = yes; then
 694                 #
 695                 # Yes.
 696                 #
 697                 AC_DEFINE(HAVE_DECL_ETHER_NTOHOST, 1,
 698                     [Define to 1 if you have the declaration of `ether_ntohost'])
 699         else
 700                 #
 701                 # No, we'll have to declare it ourselves.
 702                 # Do we have "struct ether_addr" if we include
 703                 # <netinet/if_ether.h>?
 704                 #
 705                 AC_CHECK_TYPES(struct ether_addr,,,
 706                     [
 707                         #include <sys/types.h>
 708                         #include <sys/socket.h>
 709                         #include <net/if.h>
 710                         #include <netinet/in.h>
 711                         #include <netinet/if_ether.h>
 712                     ])
 713         fi
 714 fi
 715
 716 dnl
 717 dnl Check for "pcap_list_datalinks()" and use a substitute version if
 718 dnl it's not present.  If it is present, check for "pcap_free_datalinks()";
 719 dnl if it's not present, we don't replace it for now.  (We could do so
 720 dnl on UN*X, but not on Windows, where hilarity ensues if a program
 721 dnl built with one version of the MSVC support library tries to free
 722 dnl something allocated by a library built with another version of
 723 dnl the MSVC support library.)
 724 dnl
 725 AC_CHECK_FUNC(pcap_list_datalinks,
 726         [
 727             AC_DEFINE(HAVE_PCAP_LIST_DATALINKS, 1,
 728                 [define if libpcap has pcap_list_datalinks()])
 729             AC_CHECK_FUNCS(pcap_free_datalinks)
 730         ],
 731         [
 732             AC_LIBOBJ(datalinks)
 733         ])
 734
 735 dnl
 736 dnl Check for "pcap_datalink_name_to_val()", and use a substitute
 737 dnl version if it's not present.  If it is present, check for
 738 dnl "pcap_datalink_val_to_description()", and if we don't have it,
 739 dnl use a substitute version.
 740 dnl
 741 AC_CHECK_FUNC(pcap_datalink_name_to_val,
 742         [
 743             AC_DEFINE(HAVE_PCAP_DATALINK_NAME_TO_VAL, 1,
 744                 [define if libpcap has pcap_datalink_name_to_val()])
 745             AC_CHECK_FUNC(pcap_datalink_val_to_description,
 746                 AC_DEFINE(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION, 1,
 747                     [define if libpcap has pcap_datalink_val_to_description()]),
 748                 [
 749                     AC_LIBOBJ(dlnames)
 750                 ])
 751         ],
 752         [
 753             AC_LIBOBJ(dlnames)
 754         ])
 755
 756 dnl
 757 dnl Check for "pcap_set_datalink()"; you can't substitute for it if
 758 dnl it's absent (it has hooks into libpcap), so just define the
 759 dnl HAVE_ value if it's there.
 760 dnl
 761 AC_CHECK_FUNCS(pcap_set_datalink)
 762
 763 dnl
 764 dnl Check for "pcap_breakloop()"; you can't substitute for it if
 765 dnl it's absent (it has hooks into the live capture routines),
 766 dnl so just define the HAVE_ value if it's there.
 767 dnl
 768 AC_CHECK_FUNCS(pcap_breakloop)
 769
 770 #
 771 # Do we have the new open API?  Check for pcap_create, and assume that,
 772 # if we do, we also have pcap_activate() and the other new routines
 773 # introduced in libpcap 1.0.0.
 774 #
 775 AC_CHECK_FUNCS(pcap_create)
 776 if test $ac_cv_func_pcap_create = "yes" ; then
 777         #
 778         # OK, do we have pcap_set_tstamp_type?  If so, assume we have
 779         # pcap_list_tstamp_types and pcap_free_tstamp_types as well.
 780         #
 781         AC_CHECK_FUNCS(pcap_set_tstamp_type)
 782         #
 783         # And do we have pcap_set_tstamp_precision?  If so, we assume
 784         # we also have pcap_open_offline_with_tstamp_precision.
 785         #
 786         AC_CHECK_FUNCS(pcap_set_tstamp_precision)
 787 fi
 788
 789 #
 790 # Check for a miscellaneous collection of functions which we use
 791 # if we have them.
 792 #
 793 AC_CHECK_FUNCS(pcap_findalldevs)
 794 AC_CHECK_FUNCS(pcap_dump_flush pcap_lib_version)
 795 if test $ac_cv_func_pcap_lib_version = "no" ; then
 796     AC_MSG_CHECKING(whether pcap_version is defined by libpcap)
 797     AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
 798         extern char pcap_version[];
 799
 800         return (int)pcap_version;
 801        ]])
 802        ],
 803        [ac_lbl_cv_pcap_version_defined=yes],
 804        [ac_lbl_cv_pcap_version_defined=no])
 805     if test "$ac_lbl_cv_pcap_version_defined" = yes ; then
 806         AC_MSG_RESULT(yes)
 807         AC_DEFINE(HAVE_PCAP_VERSION, 1, [define if libpcap has pcap_version])
 808     else
 809         AC_MSG_RESULT(no)
 810     fi
 811 fi
 812 AC_CHECK_FUNCS(pcap_setdirection pcap_set_immediate_mode pcap_dump_ftell64)
 813 AC_CHECK_FUNCS(pcap_open pcap_findalldevs_ex)
 814 AC_REPLACE_FUNCS(pcap_dump_ftell)
 815
 816 #
 817 # Check for special debugging functions
 818 #
 819 AC_CHECK_FUNCS(pcap_set_parser_debug)
 820 if test "$ac_cv_func_pcap_set_parser_debug" = "no" ; then
 821         #
 822         # OK, we don't have pcap_set_parser_debug() to set the libpcap
 823         # filter expression parser debug flag; can we directly set the
 824         # flag?
 825         AC_MSG_CHECKING(whether pcap_debug is defined by libpcap)
 826         AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
 827                 extern int pcap_debug;
 828
 829                 return pcap_debug;
 830            ]])
 831            ],
 832            [ac_lbl_cv_pcap_debug_defined=yes],
 833            [ac_lbl_cv_pcap_debug_defined=no])
 834         if test "$ac_lbl_cv_pcap_debug_defined" = yes ; then
 835                 AC_MSG_RESULT(yes)
 836                 AC_DEFINE(HAVE_PCAP_DEBUG, 1, [define if libpcap has pcap_debug])
 837         else
 838                 AC_MSG_RESULT(no)
 839                 #
 840                 # OK, what about "yydebug"?
 841                 #
 842                 AC_MSG_CHECKING(whether yydebug is defined by libpcap)
 843                 AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[
 844                         extern int yydebug;
 845
 846                         return yydebug;
 847                    ]])
 848                    ],
 849                    [ac_lbl_cv_yydebug_defined=yes],
 850                    [ac_lbl_cv_yydebug_defined=no])
 851                 if test "$ac_lbl_cv_yydebug_defined" = yes ; then
 852                         AC_MSG_RESULT(yes)
 853                         AC_DEFINE(HAVE_YYDEBUG, 1, [define if libpcap has yydebug])
 854                 else
 855                         AC_MSG_RESULT(no)
 856                 fi
 857         fi
 858 fi
 859 AC_CHECK_FUNCS(pcap_set_optimizer_debug)
 860 AC_REPLACE_FUNCS(bpf_dump)      dnl moved to libpcap in 0.6
 861
 862 V_GROUP=0
 863 if test -f /etc/group -a ! -z "`grep '^wheel:' /etc/group`" ; then
 864         V_GROUP=wheel
 865 fi
 866 #
 867 # Assume V7/BSD convention for man pages (file formats in section 5,
 868 # miscellaneous info in section 7).
 869 #
 870 MAN_FILE_FORMATS=5
 871 MAN_MISC_INFO=7
 872 case "$host_os" in
 873
 874 aix*)
 875         dnl Workaround to enable certain features
 876         AC_DEFINE(_SUN,1,[define on AIX to get certain functions])
 877         ;;
 878
 879 hpux*)
 880         #
 881         # Use System V conventions for man pages.
 882         #
 883         MAN_FILE_FORMATS=4
 884         MAN_MISC_INFO=5
 885         ;;
 886
 887 irix*)
 888         V_GROUP=sys
 889
 890         #
 891         # Use System V conventions for man pages.
 892         #
 893         MAN_FILE_FORMATS=4
 894         MAN_MISC_INFO=5
 895         ;;
 896
 897 osf*)
 898         V_GROUP=system
 899
 900         #
 901         # Use System V conventions for man pages.
 902         #
 903         MAN_FILE_FORMATS=4
 904         MAN_MISC_INFO=5
 905         ;;
 906
 907 solaris*)
 908         V_GROUP=sys
 909
 910         #
 911         # Use System V conventions for man pages.
 912         #
 913         MAN_FILE_FORMATS=4
 914         MAN_MISC_INFO=5
 915         ;;
 916 esac
 917
 918 if test -f /dev/bpf0 ; then
 919         V_GROUP=bpf
 920 fi
 921
 922 #
 923 # Make sure we have a definition for C99's uintptr_t (regardless of
 924 # whether the environment is a C99 environment or not).
 925 #
 926 AC_TYPE_UINTPTR_T
 927
 928 savedcppflags="$CPPFLAGS"
 929 CPPFLAGS="$CPPFLAGS $V_INCLS"
 930
 931 #
 932 # Check whether we have pcap/pcap-inttypes.h.
 933 # If we do, we use that to get the C99 types defined.
 934 #
 935 AC_CHECK_HEADERS(pcap/pcap-inttypes.h)
 936
 937 #
 938 # At compile time HAVE_PCAP_FINDALLDEVS depends on HAVE_PCAP_IF_T.
 939 #
 940 AC_CHECK_TYPES(pcap_if_t, , , [#include <pcap.h>])
 941
 942 CPPFLAGS="$savedcppflags"
 943
 944 #
 945 # Define the old BSD specified-width types in terms of the C99 types;
 946 # we may need them with libpcap include files.
 947 #
 948 AC_CHECK_TYPE([u_int8_t], ,
 949         [AC_DEFINE([u_int8_t], [uint8_t],
 950         [Define to `uint8_t' if u_int8_t not defined.])],
 951         [AC_INCLUDES_DEFAULT
 952 #include <sys/types.h>
 953 ])
 954 AC_CHECK_TYPE([u_int16_t], ,
 955         [AC_DEFINE([u_int16_t], [uint16_t],
 956         [Define to `uint16_t' if u_int16_t not defined.])],
 957         [AC_INCLUDES_DEFAULT
 958 #include <sys/types.h>
 959 ])
 960 AC_CHECK_TYPE([u_int32_t], ,
 961         [AC_DEFINE([u_int32_t], [uint32_t],
 962         [Define to `uint32_t' if u_int32_t not defined.])],
 963         [AC_INCLUDES_DEFAULT
 964 #include <sys/types.h>
 965 ])
 966 AC_CHECK_TYPE([u_int64_t], ,
 967         [AC_DEFINE([u_int64_t], [uint64_t],
 968         [Define to `uint64_t' if u_int64_t not defined.])],
 969         [AC_INCLUDES_DEFAULT
 970 #include <sys/types.h>
 971 ])
 972
 973 AC_PROG_RANLIB
 974 AC_CHECK_TOOL([AR], [ar])
 975
 976 AC_LBL_DEVEL(V_CCOPT)
 977
 978 # Check for OpenSSL/libressl libcrypto
 979 AC_MSG_CHECKING(whether to use OpenSSL/libressl libcrypto)
 980 # Specify location for both includes and libraries.
 981 want_libcrypto=ifavailable
 982 AC_ARG_WITH(crypto,
 983     AS_HELP_STRING([--with-crypto]@<:@=DIR@:>@,
 984                    [use OpenSSL/libressl libcrypto (located in directory DIR, if specified) @<:@default=yes, if available@:>@]),
 985 [
 986         if test $withval = no
 987         then
 988                 # User doesn't want to link with libcrypto.
 989                 want_libcrypto=no
 990                 AC_MSG_RESULT(no)
 991         elif test $withval = yes
 992         then
 993                 # User wants to link with libcrypto but hasn't specified
 994                 # a directory.
 995                 want_libcrypto=yes
 996                 AC_MSG_RESULT(yes)
 997         else
 998                 # User wants to link with libcrypto and has specified
 999                 # a directory, so use the provided value.
1000                 want_libcrypto=yes
1001                 libcrypto_root=$withval
1002                 AC_MSG_RESULT([yes, using the version installed in $withval])
1003
1004                 #
1005                 # Put the subdirectories of the libcrypto root directory
1006                 # at the front of the header and library search path.
1007                 #
1008                 CFLAGS="-I$withval/include $CFLAGS"
1009                 LIBS="-L$withval/lib $LIBS"
1010         fi
1011 ],[
1012         #
1013         # Use libcrypto if it's present, otherwise don't; no directory
1014         # was specified.
1015         #
1016         want_libcrypto=ifavailable
1017         AC_MSG_RESULT([yes, if available])
1018 ])
1019 if test "$want_libcrypto" != "no"; then
1020         #
1021         # Don't check for libcrypto unless we have its headers;
1022         # Apple, bless their pointy little heads, apparently ship
1023         # libcrypto as a library, but not the header files, in
1024         # El Capitan, probably because they don't want you writing
1025         # nasty portable code that could run on other UN*Xes, they
1026         # want you writing code that uses their Shiny New Crypto
1027         # Library and that only runs on macOS.
1028         #
1029         AC_CHECK_HEADER(openssl/crypto.h,
1030         [
1031                 AC_CHECK_LIB(crypto, DES_cbc_encrypt)
1032                 if test "$ac_cv_lib_crypto_DES_cbc_encrypt" = "yes"; then
1033                         AC_CHECK_HEADERS(openssl/evp.h)
1034                         #
1035                         # OK, then:
1036                         #
1037                         # 1) do we have EVP_CIPHER_CTX_new?
1038                         # If so, we use it to allocate an
1039                         # EVP_CIPHER_CTX, as EVP_CIPHER_CTX may be
1040                         # opaque; otherwise, we allocate it ourselves.
1041                         #
1042                         # 2) do we have EVP_DecryptInit_ex()?
1043                         # If so, we use it, because we need to be
1044                         # able to make two "initialize the cipher"
1045                         # calls, one with the cipher and key, and
1046                         # one with the IV, and, as of OpenSSL 1.1,
1047                         # You Can't Do That with EVP_DecryptInit(),
1048                         # because a call to EVP_DecryptInit() will
1049                         # unconditionally clear the context, and
1050                         # if you don't supply a cipher, it'll
1051                         # clear the cipher, rendering the context
1052                         # unusable and causing a crash.
1053                         #
1054                         AC_CHECK_FUNCS(EVP_CIPHER_CTX_new EVP_DecryptInit_ex)
1055                 fi
1056         ])
1057 fi
1058
1059 # Check for libcap-ng
1060 AC_MSG_CHECKING(whether to use libcap-ng)
1061 # Specify location for both includes and libraries.
1062 want_libcap_ng=ifavailable
1063 AC_ARG_WITH(cap_ng,
1064     AS_HELP_STRING([--with-cap-ng],
1065                    [use libcap-ng @<:@default=yes, if available@:>@]),
1066 [
1067         if test $withval = no
1068         then
1069                 want_libcap_ng=no
1070                 AC_MSG_RESULT(no)
1071         elif test $withval = yes
1072         then
1073                 want_libcap_ng=yes
1074                 AC_MSG_RESULT(yes)
1075         fi
1076 ],[
1077         #
1078         # Use libcap-ng if it's present, otherwise don't.
1079         #
1080         want_libcap_ng=ifavailable
1081         AC_MSG_RESULT([yes, if available])
1082 ])
1083 if test "$want_libcap_ng" != "no"; then
1084         AC_CHECK_LIB(cap-ng, capng_change_id)
1085         AC_CHECK_HEADERS(cap-ng.h)
1086 fi
1087
1088 dnl
1089 dnl set additional include path if necessary
1090 if test "$missing_includes" = "yes"; then
1091         CPPFLAGS="$CPPFLAGS -I$srcdir/missing"
1092         V_INCLS="$V_INCLS -I$srcdir/missing"
1093 fi
1094
1095 AC_SUBST(V_CCOPT)
1096 AC_SUBST(V_DEFS)
1097 AC_SUBST(V_GROUP)
1098 AC_SUBST(V_INCLS)
1099 AC_SUBST(V_PCAPDEP)
1100 AC_SUBST(LOCALSRC)
1101 AC_SUBST(MAN_FILE_FORMATS)
1102 AC_SUBST(MAN_MISC_INFO)
1103
1104 AC_PROG_INSTALL
1105
1106 AC_CONFIG_HEADER(config.h)
1107
1108 AC_CONFIG_COMMANDS([.devel],[[if test -f .devel; then
1109         echo timestamp > stamp-h
1110         cat $srcdir/Makefile-devel-adds >> Makefile
1111         make depend || exit 1
1112 fi]],[[]])
1113 AC_CONFIG_FILES([Makefile tcpdump.1])
1114 AC_OUTPUT
1115 exit 0