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