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