configure.ac

   1 dnl Copyright (c) 2001-2004, Roger Dingledine
   2 dnl Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson
   3 dnl Copyright (c) 2007-2019, The Tor Project, Inc.
   4 dnl See LICENSE for licensing information
   5
   6 AC_PREREQ([2.63])
   7 AC_INIT([tor],[0.3.5.8-dev])
   8 AC_CONFIG_SRCDIR([src/app/main/tor_main.c])
   9 AC_CONFIG_MACRO_DIR([m4])
  10
  11 # "foreign" means we don't follow GNU package layout standards
  12 # "1.11" means we require automake version 1.11 or newer
  13 # "subdir-objects" means put .o files in the same directory as the .c files
  14 AM_INIT_AUTOMAKE([foreign 1.11 subdir-objects -Wall -Werror])
  15
  16 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
  17 AC_CONFIG_HEADERS([orconfig.h])
  18
  19 AC_USE_SYSTEM_EXTENSIONS
  20 AC_CANONICAL_HOST
  21
  22 PKG_PROG_PKG_CONFIG
  23
  24 AC_ARG_ENABLE(openbsd-malloc,
  25    AS_HELP_STRING(--enable-openbsd-malloc, [use malloc code from OpenBSD.  Linux only. Deprecated: see --with-malloc]))
  26 AC_ARG_ENABLE(static-openssl,
  27    AS_HELP_STRING(--enable-static-openssl, [link against a static openssl library. Requires --with-openssl-dir]))
  28 AC_ARG_ENABLE(static-libevent,
  29    AS_HELP_STRING(--enable-static-libevent, [link against a static libevent library. Requires --with-libevent-dir]))
  30 AC_ARG_ENABLE(static-zlib,
  31    AS_HELP_STRING(--enable-static-zlib, [link against a static zlib library. Requires --with-zlib-dir]))
  32 AC_ARG_ENABLE(static-tor,
  33    AS_HELP_STRING(--enable-static-tor, [create an entirely static Tor binary. Requires --with-openssl-dir and --with-libevent-dir and --with-zlib-dir]))
  34 AC_ARG_ENABLE(unittests,
  35    AS_HELP_STRING(--disable-unittests, [don't build unit tests for Tor. Risky!]))
  36 AC_ARG_ENABLE(coverage,
  37    AS_HELP_STRING(--enable-coverage, [enable coverage support in the unit-test build]))
  38 AC_ARG_ENABLE(asserts-in-tests,
  39    AS_HELP_STRING(--disable-asserts-in-tests, [disable tor_assert() calls in the unit tests, for branch coverage]))
  40 AC_ARG_ENABLE(system-torrc,
  41    AS_HELP_STRING(--disable-system-torrc, [don't look for a system-wide torrc file]))
  42 AC_ARG_ENABLE(libfuzzer,
  43    AS_HELP_STRING(--enable-libfuzzer, [build extra fuzzers based on 'libfuzzer']))
  44 AC_ARG_ENABLE(oss-fuzz,
  45    AS_HELP_STRING(--enable-oss-fuzz, [build extra fuzzers based on 'oss-fuzz' environment]))
  46 AC_ARG_ENABLE(memory-sentinels,
  47    AS_HELP_STRING(--disable-memory-sentinels, [disable code that tries to prevent some kinds of memory access bugs. For fuzzing only.]))
  48 AC_ARG_ENABLE(rust,
  49    AS_HELP_STRING(--enable-rust, [enable rust integration]))
  50 AC_ARG_ENABLE(cargo-online-mode,
  51    AS_HELP_STRING(--enable-cargo-online-mode, [Allow cargo to make network requests to fetch crates. For builds with rust only.]))
  52 AC_ARG_ENABLE(restart-debugging,
  53    AS_HELP_STRING(--enable-restart-debugging, [Build Tor with support for debugging in-process restart. Developers only.]))
  54 AC_ARG_ENABLE(zstd-advanced-apis,
  55    AS_HELP_STRING(--disable-zstd-advanced-apis, [Build without support for zstd's "static-only" APIs.]))
  56 AC_ARG_ENABLE(nss,
  57    AS_HELP_STRING(--enable-nss, [Use Mozilla's NSS TLS library. (EXPERIMENTAL)]))
  58 AC_ARG_ENABLE(pic,
  59    AS_HELP_STRING(--enable-pic, [Build Tor's binaries as position-independent code, suitable to link as a library.]))
  60
  61 if test "x$enable_coverage" != "xyes" -a "x$enable_asserts_in_tests" = "xno" ; then
  62     AC_MSG_ERROR([Can't disable assertions outside of coverage build])
  63 fi
  64
  65 AM_CONDITIONAL(UNITTESTS_ENABLED, test "x$enable_unittests" != "xno")
  66 AM_CONDITIONAL(COVERAGE_ENABLED, test "x$enable_coverage" = "xyes")
  67 AM_CONDITIONAL(DISABLE_ASSERTS_IN_UNIT_TESTS, test "x$enable_asserts_in_tests" = "xno")
  68 AM_CONDITIONAL(LIBFUZZER_ENABLED, test "x$enable_libfuzzer" = "xyes")
  69 AM_CONDITIONAL(OSS_FUZZ_ENABLED, test "x$enable_oss_fuzz" = "xyes")
  70 AM_CONDITIONAL(USE_RUST, test "x$enable_rust" = "xyes")
  71 AM_CONDITIONAL(USE_NSS, test "x$enable_nss" = "xyes")
  72 AM_CONDITIONAL(USE_OPENSSL, test "x$enable_nss" != "xyes")
  73
  74 if test "x$enable_nss" = "xyes"; then
  75   AC_DEFINE(ENABLE_NSS, 1,
  76             [Defined if we're building with NSS.])
  77 else
  78   AC_DEFINE(ENABLE_OPENSSL, 1,
  79             [Defined if we're building with OpenSSL or LibreSSL])
  80 fi
  81
  82 if test "$enable_static_tor" = "yes"; then
  83   enable_static_libevent="yes";
  84   enable_static_openssl="yes";
  85   enable_static_zlib="yes";
  86   CFLAGS="$CFLAGS -static"
  87 fi
  88
  89 if test "$enable_system_torrc" = "no"; then
  90   AC_DEFINE(DISABLE_SYSTEM_TORRC, 1,
  91             [Defined if we're not going to look for a torrc in SYSCONF])
  92 fi
  93
  94 if test "$enable_memory_sentinels" = "no"; then
  95   AC_DEFINE(DISABLE_MEMORY_SENTINELS, 1,
  96            [Defined if we're turning off memory safety code to look for bugs])
  97 fi
  98
  99 AC_ARG_ENABLE(asciidoc,
 100      AS_HELP_STRING(--disable-asciidoc, [don't use asciidoc (disables building of manpages)]),
 101      [case "${enableval}" in
 102         "yes") asciidoc=true ;;
 103         "no")  asciidoc=false ;;
 104         *) AC_MSG_ERROR(bad value for --disable-asciidoc) ;;
 105       esac], [asciidoc=true])
 106
 107 # systemd notify support
 108 AC_ARG_ENABLE(systemd,
 109       AS_HELP_STRING(--enable-systemd, [enable systemd notification support]),
 110       [case "${enableval}" in
 111         "yes") systemd=true ;;
 112         "no")  systemd=false ;;
 113         * ) AC_MSG_ERROR(bad value for --enable-systemd) ;;
 114       esac], [systemd=auto])
 115
 116 if test "$enable_restart_debugging" = "yes"; then
 117   AC_DEFINE(ENABLE_RESTART_DEBUGGING, 1,
 118             [Defined if we're building with support for in-process restart debugging.])
 119 fi
 120
 121 if test "$enable_zstd_advanced_apis" != "no"; then
 122    AC_DEFINE(ENABLE_ZSTD_ADVANCED_APIS, 1,
 123              [Defined if we're going to try to use zstd's "static-only" APIs.])
 124 fi
 125
 126 # systemd support
 127 if test "x$enable_systemd" = "xno"; then
 128     have_systemd=no;
 129 else
 130     PKG_CHECK_MODULES(SYSTEMD,
 131         [libsystemd-daemon],
 132         have_systemd=yes,
 133         have_systemd=no)
 134     if test "x$have_systemd" = "xno"; then
 135         AC_MSG_NOTICE([Okay, checking for systemd a different way...])
 136         PKG_CHECK_MODULES(SYSTEMD,
 137             [libsystemd],
 138             have_systemd=yes,
 139             have_systemd=no)
 140     fi
 141 fi
 142
 143 if test "x$have_systemd" = "xyes"; then
 144     AC_DEFINE(HAVE_SYSTEMD,1,[Have systemd])
 145     TOR_SYSTEMD_CFLAGS="${SYSTEMD_CFLAGS}"
 146     TOR_SYSTEMD_LIBS="${SYSTEMD_LIBS}"
 147     PKG_CHECK_MODULES(LIBSYSTEMD209, [libsystemd >= 209],
 148          [AC_DEFINE(HAVE_SYSTEMD_209,1,[Have systemd v209 or more])], [])
 149 fi
 150 AC_SUBST(TOR_SYSTEMD_CFLAGS)
 151 AC_SUBST(TOR_SYSTEMD_LIBS)
 152
 153 if test "x$enable_systemd" = "xyes" -a "x$have_systemd" != "xyes" ; then
 154     AC_MSG_ERROR([Explicitly requested systemd support, but systemd not found])
 155 fi
 156
 157 case "$host" in
 158    *-*-solaris* )
 159      AC_DEFINE(_REENTRANT, 1, [Define on some platforms to activate x_r() functions in time.h])
 160      ;;
 161 esac
 162
 163 AC_ARG_ENABLE(gcc-warnings,
 164      AS_HELP_STRING(--enable-gcc-warnings, [deprecated alias for enable-fatal-warnings]))
 165 AC_ARG_ENABLE(fatal-warnings,
 166      AS_HELP_STRING(--enable-fatal-warnings, [tell the compiler to treat all warnings as errors.]))
 167 AC_ARG_ENABLE(gcc-warnings-advisory,
 168      AS_HELP_STRING(--disable-gcc-warnings-advisory, [disable the regular verbose warnings]))
 169
 170 dnl Others suggest '/gs /safeseh /nxcompat /dynamicbase' for non-gcc on Windows
 171 AC_ARG_ENABLE(gcc-hardening,
 172     AS_HELP_STRING(--disable-gcc-hardening, [disable compiler security checks]))
 173
 174 dnl Deprecated --enable-expensive-hardening but keep it for now for backward compat.
 175 AC_ARG_ENABLE(expensive-hardening,
 176     AS_HELP_STRING(--enable-expensive-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
 177 AC_ARG_ENABLE(fragile-hardening,
 178     AS_HELP_STRING(--enable-fragile-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
 179 if test "x$enable_expensive_hardening" = "xyes" || test "x$enable_fragile_hardening" = "xyes"; then
 180   fragile_hardening="yes"
 181   AC_DEFINE(DEBUG_SMARTLIST, 1, [Enable smartlist debugging])
 182 fi
 183
 184 dnl Linker hardening options
 185 dnl Currently these options are ELF specific - you can't use this with MacOSX
 186 AC_ARG_ENABLE(linker-hardening,
 187     AS_HELP_STRING(--disable-linker-hardening, [disable linker security fixups]))
 188
 189 AC_ARG_ENABLE(local-appdata,
 190    AS_HELP_STRING(--enable-local-appdata, [default to host local application data paths on Windows]))
 191 if test "$enable_local_appdata" = "yes"; then
 192   AC_DEFINE(ENABLE_LOCAL_APPDATA, 1,
 193             [Defined if we default to host local appdata paths on Windows])
 194 fi
 195
 196 AC_ARG_ENABLE(tool-name-check,
 197      AS_HELP_STRING(--disable-tool-name-check, [check for sanely named toolchain when cross-compiling]))
 198
 199 AC_ARG_ENABLE(seccomp,
 200      AS_HELP_STRING(--disable-seccomp, [do not attempt to use libseccomp]))
 201
 202 AC_ARG_ENABLE(libscrypt,
 203      AS_HELP_STRING(--disable-libscrypt, [do not attempt to use libscrypt]))
 204
 205 dnl Enable event tracing which are transformed to debug log statement.
 206 AC_ARG_ENABLE(event-tracing-debug,
 207      AS_HELP_STRING(--enable-event-tracing-debug, [build with event tracing to debug log]))
 208 AM_CONDITIONAL([USE_EVENT_TRACING_DEBUG], [test "x$enable_event_tracing_debug" = "xyes"])
 209
 210 if test x$enable_event_tracing_debug = xyes; then
 211   AC_DEFINE([USE_EVENT_TRACING_DEBUG], [1], [Tracing framework to log debug])
 212   AC_DEFINE([TOR_EVENT_TRACING_ENABLED], [1], [Compile the event tracing instrumentation])
 213 fi
 214
 215 dnl Enable Android only features.
 216 AC_ARG_ENABLE(android,
 217      AS_HELP_STRING(--enable-android, [build with Android features enabled]))
 218 AM_CONDITIONAL([USE_ANDROID], [test "x$enable_android" = "xyes"])
 219
 220 if test "x$enable_android" = "xyes"; then
 221   AC_DEFINE([USE_ANDROID], [1], [Compile with Android specific features enabled])
 222
 223   dnl Check if the Android log library is available.
 224   AC_CHECK_HEADERS([android/log.h])
 225   AC_SEARCH_LIBS(__android_log_write, [log])
 226
 227 fi
 228
 229 dnl ---
 230 dnl Tor modules options. These options are namespaced with --disable-module-XXX
 231 dnl ---
 232
 233 dnl All our modules.
 234 m4_define(MODULES, dirauth)
 235
 236 dnl Directory Authority module.
 237 AC_ARG_ENABLE([module-dirauth],
 238               AS_HELP_STRING([--disable-module-dirauth],
 239                              [Do not build tor with the dirauth module]),
 240               [], dnl Action if-given
 241               AC_DEFINE([HAVE_MODULE_DIRAUTH], [1],
 242                         [Compile with Directory Authority feature support]))
 243 AM_CONDITIONAL(BUILD_MODULE_DIRAUTH, [test "x$enable_module_dirauth" != "xno"])
 244
 245 dnl Helper variables.
 246 TOR_MODULES_ALL_ENABLED=
 247 AC_DEFUN([ADD_MODULE], [
 248     MODULE=m4_toupper($1)
 249     TOR_MODULES_ALL_ENABLED="${TOR_MODULES_ALL_ENABLED} -DHAVE_MODULE_${MODULE}=1"
 250 ])
 251 m4_foreach_w([module], MODULES, [ADD_MODULE([module])])
 252 AC_SUBST(TOR_MODULES_ALL_ENABLED)
 253
 254 dnl check for the correct "ar" when cross-compiling.
 255 dnl   (AM_PROG_AR was new in automake 1.11.2, which we do not yet require,
 256 dnl    so kludge up a replacement for the case where it isn't there yet.)
 257 m4_ifdef([AM_PROG_AR],
 258          [AM_PROG_AR],
 259          [AN_MAKEVAR([AR], [AC_PROG_AR])
 260           AN_PROGRAM([ar], [AC_PROG_AR])
 261           AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL([AR], [ar], [:])])
 262           AC_PROG_AR])
 263
 264 dnl Check whether the above macro has settled for a simply named tool even
 265 dnl though we're cross compiling. We must do this before running AC_PROG_CC,
 266 dnl because that will find any cc on the system, not only the cross-compiler,
 267 dnl and then verify that a binary built with this compiler runs on the
 268 dnl build system. It will then come to the false conclusion that we're not
 269 dnl cross-compiling.
 270 if test "x$enable_tool_name_check" != "xno"; then
 271     if test "x$ac_tool_warned" = "xyes"; then
 272         AC_MSG_ERROR([We are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
 273         elif test "x$ac_ct_AR" != "x" -a "x$cross_compiling" = "xmaybe"; then
 274                 AC_MSG_ERROR([We think we are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
 275         fi
 276 fi
 277
 278 AC_PROG_CC
 279 AC_PROG_CPP
 280 AC_PROG_MAKE_SET
 281 AC_PROG_RANLIB
 282 AC_PROG_SED
 283
 284 AC_ARG_VAR([PERL], [path to Perl binary])
 285 AC_CHECK_PROGS([PERL], [perl])
 286 AM_CONDITIONAL(USE_PERL, [test "x$ac_cv_prog_PERL" != "x"])
 287
 288 dnl check for asciidoc and a2x
 289 AC_PATH_PROG([ASCIIDOC], [asciidoc], none)
 290 AC_PATH_PROGS([A2X], [a2x a2x.py], none)
 291
 292 AM_CONDITIONAL(USE_ASCIIDOC, test "x$asciidoc" = "xtrue")
 293
 294 AM_PROG_CC_C_O
 295 AC_PROG_CC_C99
 296
 297 AC_ARG_VAR([PYTHON], [path to Python binary])
 298 AC_CHECK_PROGS(PYTHON, [ \
 299         python3 \
 300         python3.8 python3.7 python3.6 python3.5 python3.4 \
 301         python \
 302         python2 python2.7])
 303 if test "x$PYTHON" = "x"; then
 304   AC_MSG_WARN([Python unavailable; some tests will not be run.])
 305 fi
 306 AM_CONDITIONAL(USEPYTHON, [test "x$PYTHON" != "x"])
 307
 308 dnl List all external rust crates we depend on here. Include the version
 309 rust_crates=" \
 310     digest-0.7.2 \
 311     libc-0.2.39 \
 312 "
 313 AC_SUBST(rust_crates)
 314
 315 ifdef([AC_C_FLEXIBLE_ARRAY_MEMBER], [
 316 AC_C_FLEXIBLE_ARRAY_MEMBER
 317 ], [
 318  dnl Maybe we've got an old autoconf...
 319  AC_CACHE_CHECK([for flexible array members],
 320      tor_cv_c_flexarray,
 321      [AC_COMPILE_IFELSE(
 322        AC_LANG_PROGRAM([
 323  struct abc { int a; char b[]; };
 324 ], [
 325  struct abc *def = malloc(sizeof(struct abc)+sizeof(char));
 326  def->b[0] = 33;
 327 ]),
 328   [tor_cv_c_flexarray=yes],
 329   [tor_cv_c_flexarray=no])])
 330  if test "$tor_cv_flexarray" = "yes"; then
 331    AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
 332  else
 333    AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
 334  fi
 335 ])
 336
 337 AC_CACHE_CHECK([for working C99 mid-block declaration syntax],
 338       tor_cv_c_c99_decl,
 339       [AC_COMPILE_IFELSE(
 340          [AC_LANG_PROGRAM([], [int x; x = 3; int y; y = 4 + x;])],
 341          [tor_cv_c_c99_decl=yes],
 342          [tor_cv_c_c99_decl=no] )])
 343 if test "$tor_cv_c_c99_decl" != "yes"; then
 344   AC_MSG_ERROR([Your compiler doesn't support c99 mid-block declarations. This is required as of Tor 0.2.6.x])
 345 fi
 346
 347 AC_CACHE_CHECK([for working C99 designated initializers],
 348       tor_cv_c_c99_designated_init,
 349       [AC_COMPILE_IFELSE(
 350          [AC_LANG_PROGRAM([struct s { int a; int b; };],
 351                [[ struct s ss = { .b = 5, .a = 6 }; ]])],
 352          [tor_cv_c_c99_designated_init=yes],
 353          [tor_cv_c_c99_designated_init=no] )])
 354
 355 if test "$tor_cv_c_c99_designated_init" != "yes"; then
 356   AC_MSG_ERROR([Your compiler doesn't support c99 designated initializers. This is required as of Tor 0.2.6.x])
 357 fi
 358
 359 TORUSER=_tor
 360 AC_ARG_WITH(tor-user,
 361         AS_HELP_STRING(--with-tor-user=NAME, [specify username for tor daemon]),
 362         [
 363            TORUSER=$withval
 364         ]
 365 )
 366 AC_SUBST(TORUSER)
 367
 368 TORGROUP=_tor
 369 AC_ARG_WITH(tor-group,
 370         AS_HELP_STRING(--with-tor-group=NAME, [specify group name for tor daemon]),
 371         [
 372            TORGROUP=$withval
 373         ]
 374 )
 375 AC_SUBST(TORGROUP)
 376
 377
 378 dnl If _WIN32 is defined and non-zero, we are building for win32
 379 AC_MSG_CHECKING([for win32])
 380 AC_RUN_IFELSE([AC_LANG_SOURCE([
 381 int main(int c, char **v) {
 382 #ifdef _WIN32
 383 #if _WIN32
 384   return 0;
 385 #else
 386   return 1;
 387 #endif
 388 #else
 389   return 2;
 390 #endif
 391 }])],
 392 bwin32=true; AC_MSG_RESULT([yes]),
 393 bwin32=false; AC_MSG_RESULT([no]),
 394 bwin32=cross; AC_MSG_RESULT([cross])
 395 )
 396
 397 if test "$bwin32" = "cross"; then
 398 AC_MSG_CHECKING([for win32 (cross)])
 399 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 400 #ifdef _WIN32
 401 int main(int c, char **v) {return 0;}
 402 #else
 403 #error
 404 int main(int c, char **v) {return x(y);}
 405 #endif
 406 ])],
 407 bwin32=true; AC_MSG_RESULT([yes]),
 408 bwin32=false; AC_MSG_RESULT([no]))
 409 fi
 410
 411 AH_BOTTOM([
 412 #ifdef _WIN32
 413 /* Defined to access windows functions and definitions for >=WinXP */
 414 # ifndef WINVER
 415 #  define WINVER 0x0501
 416 # endif
 417
 418 /* Defined to access _other_ windows functions and definitions for >=WinXP */
 419 # ifndef _WIN32_WINNT
 420 #  define _WIN32_WINNT 0x0501
 421 # endif
 422
 423 /* Defined to avoid including some windows headers as part of Windows.h */
 424 # ifndef WIN32_LEAN_AND_MEAN
 425 #  define WIN32_LEAN_AND_MEAN 1
 426 # endif
 427 #endif
 428 ])
 429
 430 AM_CONDITIONAL(WIN32, test "x$bwin32" = "xtrue")
 431 AM_CONDITIONAL(BUILD_NT_SERVICES, test "x$bwin32" = "xtrue")
 432 AM_CONDITIONAL(BUILD_LIBTORRUNNER, test "x$bwin32" != "xtrue")
 433
 434 dnl Enable C99 when compiling with MIPSpro
 435 AC_MSG_CHECKING([for MIPSpro compiler])
 436 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [
 437 #if (defined(__sgi) && defined(_COMPILER_VERSION))
 438 #error
 439   return x(y);
 440 #endif
 441 ])],
 442 bmipspro=false; AC_MSG_RESULT(no),
 443 bmipspro=true; AC_MSG_RESULT(yes))
 444
 445 if test "$bmipspro" = "true"; then
 446   CFLAGS="$CFLAGS -c99"
 447 fi
 448
 449 AC_C_BIGENDIAN
 450
 451 AC_ARG_VAR([TOR_RUST_TARGET], [Rust target, must be specified when cross-compiling (HOST != BUILD). example: i686-pc-windows-gnu])
 452
 453 if test "x$enable_rust" = "xyes"; then
 454   AC_ARG_VAR([RUSTC], [path to the rustc binary])
 455   AC_CHECK_PROG([RUSTC], [rustc], [rustc],[no])
 456   if test "x$RUSTC" = "xno"; then
 457     AC_MSG_ERROR([rustc unavailable but rust integration requested.])
 458   fi
 459
 460   AC_ARG_VAR([CARGO], [path to the cargo binary])
 461   AC_CHECK_PROG([CARGO], [cargo], [cargo],[no])
 462   if test "x$CARGO" = "xno"; then
 463     AC_MSG_ERROR([cargo unavailable but rust integration requested.])
 464   fi
 465
 466   AC_DEFINE([HAVE_RUST], 1, [have Rust])
 467   if test "x$enable_fatal_warnings" = "xyes"; then
 468     RUST_WARN=
 469   else
 470     RUST_WARN=#
 471   fi
 472   if test "x$enable_cargo_online_mode" = "xyes"; then
 473     CARGO_ONLINE=
 474     RUST_DL=#
 475   else
 476     CARGO_ONLINE=--frozen
 477     RUST_DL=
 478
 479     dnl When we're not allowed to touch the network, we need crate dependencies
 480     dnl locally available.
 481     AC_MSG_CHECKING([rust crate dependencies])
 482     AC_ARG_VAR([TOR_RUST_DEPENDENCIES], [path to directory with local crate mirror])
 483     if test "x$TOR_RUST_DEPENDENCIES" = "x"; then
 484       TOR_RUST_DEPENDENCIES="${srcdir}/src/ext/rust/crates"
 485     fi
 486     dnl Check whether the path exists before we try to cd into it.
 487     if test ! -d "$TOR_RUST_DEPENDENCIES"; then
 488       AC_MSG_ERROR([Rust dependency directory $TOR_RUST_DEPENDENCIES does not exist. Specify a dependency directory using the TOR_RUST_DEPENDENCIES variable or allow cargo to fetch crates using --enable-cargo-online-mode.])
 489       ERRORED=1
 490     fi
 491     dnl Make the path absolute, since we'll be using it from within a
 492     dnl subdirectory.
 493     TOR_RUST_DEPENDENCIES=$(cd "$TOR_RUST_DEPENDENCIES" ; pwd)
 494
 495     for dep in $rust_crates; do
 496       if test ! -d "$TOR_RUST_DEPENDENCIES"/"$dep"; then
 497         AC_MSG_ERROR([Failure to find rust dependency $TOR_RUST_DEPENDENCIES/$dep. Specify a dependency directory using the TOR_RUST_DEPENDENCIES variable or allow cargo to fetch crates using --enable-cargo-online-mode.])
 498         ERRORED=1
 499       fi
 500     done
 501     if test "x$ERRORED" = "x"; then
 502       AC_MSG_RESULT([yes])
 503     fi
 504   fi
 505
 506   dnl This is a workaround for #46797
 507   dnl (a.k.a https://github.com/rust-lang/rust/issues/46797 ).  Once the
 508   dnl upstream bug is fixed, we can remove this workaround.
 509   case "$host_os" in
 510       darwin*)
 511         TOR_RUST_EXTRA_LIBS="-lresolv"
 512         ;;
 513   esac
 514
 515   dnl For now both MSVC and MinGW rust libraries will output static libs with
 516   dnl the MSVC naming convention.
 517   if test "$bwin32" = "true"; then
 518     tor_rust_static_name=tor_rust.lib
 519   else
 520     tor_rust_static_name=libtor_rust.a
 521   fi
 522
 523   AC_CANONICAL_BUILD
 524
 525   if test -n "$TOR_RUST_TARGET"; then
 526     if test "$host" = "$build"; then
 527       AC_MSG_ERROR([HOST = BUILD is invalid if TOR_RUST_TARGET is specified, see configure --help for more information.])
 528     fi
 529     RUST_TARGET_PROP="target = '$TOR_RUST_TARGET'"
 530     TOR_RUST_LIB_PATH="src/rust/target/$TOR_RUST_TARGET/release/$tor_rust_static_name"
 531   else
 532     if test "$host" != "$build"; then
 533       AC_MSG_ERROR([TOR_RUST_TARGET must be specified when cross-compiling with Rust enabled.])
 534     fi
 535     RUST_TARGET_PROP=
 536     TOR_RUST_LIB_PATH="src/rust/target/release/$tor_rust_static_name"
 537   fi
 538
 539   AC_SUBST(RUST_TARGET_PROP)
 540   AC_SUBST(TOR_RUST_LIB_PATH)
 541   AC_SUBST(CARGO_ONLINE)
 542   AC_SUBST(RUST_WARN)
 543   AC_SUBST(RUST_DL)
 544
 545   dnl Let's check the rustc version, too
 546   AC_MSG_CHECKING([rust version])
 547   RUSTC_VERSION=`$RUSTC --version`
 548   RUSTC_VERSION_MAJOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 1`
 549   RUSTC_VERSION_MINOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 2`
 550   if test "x$RUSTC_VERSION_MAJOR" = "x" -o "x$RUSTC_VERSION_MINOR" = "x"; then
 551     AC_MSG_ERROR([rustc version couldn't be identified])
 552   fi
 553   if test "$RUSTC_VERSION_MAJOR" -lt 2 -a "$RUSTC_VERSION_MINOR" -lt 14; then
 554     AC_MSG_ERROR([rustc must be at least version 1.14])
 555   fi
 556   AC_MSG_RESULT([$RUSTC_VERSION])
 557 fi
 558
 559 AC_SUBST(TOR_RUST_EXTRA_LIBS)
 560
 561 AC_SEARCH_LIBS(socket, [socket network])
 562 AC_SEARCH_LIBS(gethostbyname, [nsl])
 563 AC_SEARCH_LIBS(dlopen, [dl])
 564 AC_SEARCH_LIBS(inet_aton, [resolv])
 565 AC_SEARCH_LIBS(backtrace, [execinfo])
 566 saved_LIBS="$LIBS"
 567 AC_SEARCH_LIBS([clock_gettime], [rt])
 568 if test "$LIBS" != "$saved_LIBS"; then
 569    # Looks like we need -lrt for clock_gettime().
 570    have_rt=yes
 571 fi
 572
 573 if test "$bwin32" = "false"; then
 574   AC_SEARCH_LIBS(pthread_create, [pthread])
 575   AC_SEARCH_LIBS(pthread_detach, [pthread])
 576 fi
 577
 578 AM_CONDITIONAL(THREADS_WIN32, test "$bwin32" = "true")
 579 AM_CONDITIONAL(THREADS_PTHREADS, test "$bwin32" = "false")
 580
 581 AC_CHECK_FUNCS(
 582         _NSGetEnviron \
 583         RtlSecureZeroMemory \
 584         SecureZeroMemory \
 585         accept4 \
 586         backtrace \
 587         backtrace_symbols_fd \
 588         eventfd \
 589         explicit_bzero \
 590         timingsafe_memcmp \
 591         flock \
 592         ftime \
 593         get_current_dir_name \
 594         getaddrinfo \
 595         getdelim \
 596         getifaddrs \
 597         getline \
 598         getpass \
 599         getrlimit \
 600         gettimeofday \
 601         gmtime_r \
 602         gnu_get_libc_version \
 603         htonll \
 604         inet_aton \
 605         ioctl \
 606         issetugid \
 607         llround \
 608         localtime_r \
 609         lround \
 610         memmem \
 611         memset_s \
 612         mmap \
 613         pipe \
 614         pipe2 \
 615         prctl \
 616         readpassphrase \
 617         rint \
 618         sigaction \
 619         socketpair \
 620         statvfs \
 621         strncasecmp \
 622         strcasecmp \
 623         strlcat \
 624         strlcpy \
 625         strnlen \
 626         strptime \
 627         strtok_r \
 628         strtoull \
 629         sysconf \
 630         sysctl \
 631         truncate \
 632         uname \
 633         usleep \
 634         vasprintf \
 635         _vscprintf
 636 )
 637
 638 # Apple messed up when they added some functions: they
 639 # forgot to decorate them with appropriate AVAILABLE_MAC_OS_VERSION
 640 # checks.
 641
 642 # We should only probe for these functions if we are sure that we
 643 # are not targeting OS X 10.9 or earlier.
 644 AC_MSG_CHECKING([for a pre-Yosemite OS X build target])
 645 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 646 #ifdef __APPLE__
 647 #  include <AvailabilityMacros.h>
 648 #  ifndef MAC_OS_X_VERSION_10_10
 649 #    define MAC_OS_X_VERSION_10_10 101000
 650 #  endif
 651 #  if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
 652 #    if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_10
 653 #      error "Running on Mac OS X 10.9 or earlier"
 654 #    endif
 655 #  endif
 656 #endif
 657 ]], [[]])],
 658    [on_macos_pre_10_10=no ; AC_MSG_RESULT([no])],
 659    [on_macos_pre_10_10=yes; AC_MSG_RESULT([yes])])
 660
 661 if test "$on_macos_pre_10_10" = "no"; then
 662   AC_CHECK_FUNCS(
 663         mach_approximate_time \
 664   )
 665 fi
 666
 667 # We should only probe for these functions if we are sure that we
 668 # are not targeting OSX 10.11 or earlier.
 669 AC_MSG_CHECKING([for a pre-Sierra OSX build target])
 670 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 671 #ifdef __APPLE__
 672 #  include <AvailabilityMacros.h>
 673 #  ifndef MAC_OS_X_VERSION_10_12
 674 #    define MAC_OS_X_VERSION_10_12 101200
 675 #  endif
 676 #  if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
 677 #    if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
 678 #      error "Running on Mac OSX 10.11 or earlier"
 679 #    endif
 680 #  endif
 681 #endif
 682 ]], [[]])],
 683    [on_macos_pre_10_12=no ; AC_MSG_RESULT([no])],
 684    [on_macos_pre_10_12=yes; AC_MSG_RESULT([yes])])
 685
 686 if test "$on_macos_pre_10_12" = "no"; then
 687   AC_CHECK_FUNCS(
 688         clock_gettime \
 689         getentropy \
 690   )
 691 fi
 692
 693 if test "$bwin32" != "true"; then
 694   AC_CHECK_HEADERS(pthread.h)
 695   AC_CHECK_FUNCS(pthread_create)
 696   AC_CHECK_FUNCS(pthread_condattr_setclock)
 697 fi
 698
 699 if test "$bwin32" = "true"; then
 700   AC_CHECK_DECLS([SecureZeroMemory, _getwch], , , [
 701 #include <windows.h>
 702 #include <conio.h>
 703 #include <wchar.h>
 704                  ])
 705 fi
 706
 707 AM_CONDITIONAL(BUILD_READPASSPHRASE_C,
 708   test "x$ac_cv_func_readpassphrase" = "xno" && test "$bwin32" = "false")
 709
 710 AC_MSG_CHECKING([whether free(NULL) works])
 711 AC_RUN_IFELSE([AC_LANG_PROGRAM([
 712   #include <stdlib.h>
 713 ], [
 714 char *p = NULL;
 715 free(p);
 716 ])],
 717 [free_null_ok=true; AC_MSG_RESULT(yes)],
 718 [free_null_ok=false; AC_MSG_RESULT(no)],
 719 [free_null_ok=cross; AC_MSG_RESULT(cross)])
 720
 721 if test "$free_null_ok" = "false"; then
 722    AC_MSG_ERROR([Your libc implementation doesn't allow free(NULL), as required by C99.])
 723 fi
 724
 725 dnl ------------------------------------------------------
 726 dnl Where do you live, libevent?  And how do we call you?
 727
 728 if test "$bwin32" = "true"; then
 729   TOR_LIB_WS32=-lws2_32
 730   TOR_LIB_IPHLPAPI=-liphlpapi
 731   # Some of the cargo-cults recommend -lwsock32 as well, but I don't
 732   # think it's actually necessary.
 733   TOR_LIB_GDI=-lgdi32
 734   TOR_LIB_USERENV=-luserenv
 735 else
 736   TOR_LIB_WS32=
 737   TOR_LIB_GDI=
 738   TOR_LIB_USERENV=
 739 fi
 740 AC_SUBST(TOR_LIB_WS32)
 741 AC_SUBST(TOR_LIB_GDI)
 742 AC_SUBST(TOR_LIB_IPHLPAPI)
 743 AC_SUBST(TOR_LIB_USERENV)
 744
 745 tor_libevent_pkg_redhat="libevent"
 746 tor_libevent_pkg_debian="libevent-dev"
 747 tor_libevent_devpkg_redhat="libevent-devel"
 748 tor_libevent_devpkg_debian="libevent-dev"
 749
 750 dnl On Gnu/Linux or any place we require it, we'll add librt to the Libevent
 751 dnl linking for static builds.
 752 STATIC_LIBEVENT_FLAGS=""
 753 if test "$enable_static_libevent" = "yes"; then
 754     if test "$have_rt" = "yes"; then
 755       STATIC_LIBEVENT_FLAGS=" -lrt "
 756     fi
 757 fi
 758
 759 TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32], [
 760 #ifdef _WIN32
 761 #include <winsock2.h>
 762 #endif
 763 #include <sys/time.h>
 764 #include <sys/types.h>
 765 #include <event2/event.h>], [
 766 #ifdef _WIN32
 767 #include <winsock2.h>
 768 #endif
 769 struct event_base;
 770 struct event_base *event_base_new(void);
 771 void event_base_free(struct event_base *);],
 772     [
 773 #ifdef _WIN32
 774 {WSADATA d; WSAStartup(0x101,&d); }
 775 #endif
 776 event_base_free(event_base_new());
 777 ], [--with-libevent-dir], [/opt/libevent])
 778
 779 dnl Determine the incantation needed to link libevent.
 780 save_LIBS="$LIBS"
 781 save_LDFLAGS="$LDFLAGS"
 782 save_CPPFLAGS="$CPPFLAGS"
 783
 784 LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
 785 LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
 786 CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
 787
 788 AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
 789
 790 if test "$enable_static_libevent" = "yes"; then
 791    if test "$tor_cv_library_libevent_dir" = "(system)"; then
 792      AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
 793    else
 794      TOR_LIBEVENT_LIBS="$TOR_LIBDIR_libevent/libevent.a $STATIC_LIBEVENT_FLAGS"
 795    fi
 796 else
 797      if test "x$ac_cv_header_event2_event_h" = "xyes"; then
 798        AC_SEARCH_LIBS(event_new, [event event_core], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for event_new"))
 799        AC_SEARCH_LIBS(evdns_base_new, [event event_extra], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for evdns_base_new"))
 800
 801        if test "$ac_cv_search_event_new" != "none required"; then
 802          TOR_LIBEVENT_LIBS="$ac_cv_search_event_new"
 803        fi
 804        if test "$ac_cv_search_evdns_base_new" != "none required"; then
 805          TOR_LIBEVENT_LIBS="$ac_cv_search_evdns_base_new $TOR_LIBEVENT_LIBS"
 806        fi
 807      else
 808        AC_MSG_ERROR("libevent2 is required but the headers could not be found")
 809      fi
 810 fi
 811
 812 dnl Now check for particular libevent functions.
 813 AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file \
 814                 evutil_secure_rng_add_bytes \
 815 ])
 816
 817 LIBS="$save_LIBS"
 818 LDFLAGS="$save_LDFLAGS"
 819 CPPFLAGS="$save_CPPFLAGS"
 820
 821 dnl Check that libevent is at least at version 2.0.10, the first stable
 822 dnl release of its series
 823 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
 824 AC_MSG_CHECKING([whether Libevent is new enough])
 825 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 826 #include <event2/event.h>
 827 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
 828 #error
 829 int x = y(zz);
 830 #else
 831 int x = 1;
 832 #endif
 833 ])], [ AC_MSG_RESULT([yes]) ],
 834    [ AC_MSG_RESULT([no])
 835      AC_MSG_ERROR([Libevent is not new enough.  We require 2.0.10-stable or later]) ] )
 836
 837 LIBS="$save_LIBS"
 838 LDFLAGS="$save_LDFLAGS"
 839 CPPFLAGS="$save_CPPFLAGS"
 840
 841 AC_SUBST(TOR_LIBEVENT_LIBS)
 842
 843 dnl ------------------------------------------------------
 844 dnl Where do you live, libm?
 845
 846 dnl On some platforms (Haiku/BeOS) the math library is
 847 dnl part of libroot. In which case don't link against lm
 848 TOR_LIB_MATH=""
 849 save_LIBS="$LIBS"
 850 AC_SEARCH_LIBS(pow, [m], , AC_MSG_ERROR([Could not find pow in libm or libc.]))
 851 if test "$ac_cv_search_pow" != "none required"; then
 852     TOR_LIB_MATH="$ac_cv_search_pow"
 853 fi
 854 LIBS="$save_LIBS"
 855 AC_SUBST(TOR_LIB_MATH)
 856
 857 dnl ------------------------------------------------------
 858 dnl Hello, NSS.  You're new around here.
 859 if test "x$enable_nss" = "xyes"; then
 860   PKG_CHECK_MODULES(NSS,
 861      [nss],
 862      [have_nss=yes],
 863      [have_nss=no; AC_MSG_ERROR([You asked for NSS but I can't find it.])])
 864   AC_SUBST(NSS_CFLAGS)
 865   AC_SUBST(NSS_LIBS)
 866 fi
 867
 868 dnl ------------------------------------------------------
 869 dnl Where do you live, openssl?  And how do we call you?
 870
 871 if test "x$enable_nss" != "xyes"; then
 872
 873 tor_openssl_pkg_redhat="openssl"
 874 tor_openssl_pkg_debian="libssl-dev"
 875 tor_openssl_devpkg_redhat="openssl-devel"
 876 tor_openssl_devpkg_debian="libssl-dev"
 877
 878 ALT_openssl_WITHVAL=""
 879 AC_ARG_WITH(ssl-dir,
 880   AS_HELP_STRING(--with-ssl-dir=PATH, [obsolete alias for --with-openssl-dir]),
 881   [
 882       if test "x$withval" != "xno" && test "x$withval" != "x"; then
 883          ALT_openssl_WITHVAL="$withval"
 884       fi
 885   ])
 886
 887 AC_MSG_NOTICE([Now, we'll look for OpenSSL >= 1.0.1])
 888 TOR_SEARCH_LIBRARY(openssl, $tryssldir, [-lssl -lcrypto $TOR_LIB_GDI $TOR_LIB_WS32],
 889     [#include <openssl/ssl.h>
 890      char *getenv(const char *);],
 891     [struct ssl_cipher_st;
 892      unsigned SSL_CIPHER_get_id(const struct ssl_cipher_st *);
 893      char *getenv(const char *);],
 894     dnl This funny-looking test program calls getenv, so that the compiler
 895     dnl will neither make code that call SSL_CIPHER_get_id(NULL) [producing
 896     dnl a crash], nor optimize out the call to SSL_CIPHER_get_id().
 897     dnl We look for SSL_cipher_get_id() because it is present in
 898     dnl OpenSSL >=1.0.1, because it is not deprecated, and because Tor
 899     dnl depends on it.
 900     [if (getenv("THIS_SHOULDNT_BE_SET_X201803")) SSL_CIPHER_get_id((void *)0);], [],
 901     [/usr/local/opt/openssl /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /opt/openssl])
 902
 903 dnl XXXX check for OPENSSL_VERSION_NUMBER == SSLeay()
 904
 905 if test "$enable_static_openssl" = "yes"; then
 906    if test "$tor_cv_library_openssl_dir" = "(system)"; then
 907      AC_MSG_ERROR("You must specify an explicit --with-openssl-dir=x option when using --enable-static-openssl")
 908    else
 909      TOR_OPENSSL_LIBS="$TOR_LIBDIR_openssl/libssl.a $TOR_LIBDIR_openssl/libcrypto.a"
 910    fi
 911 else
 912      TOR_OPENSSL_LIBS="-lssl -lcrypto"
 913 fi
 914 AC_SUBST(TOR_OPENSSL_LIBS)
 915
 916 dnl Now check for particular openssl functions.
 917 save_LIBS="$LIBS"
 918 save_LDFLAGS="$LDFLAGS"
 919 save_CPPFLAGS="$CPPFLAGS"
 920 LIBS="$TOR_OPENSSL_LIBS $LIBS"
 921 LDFLAGS="$TOR_LDFLAGS_openssl $LDFLAGS"
 922 CPPFLAGS="$TOR_CPPFLAGS_openssl $CPPFLAGS"
 923
 924 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 925 #include <openssl/opensslv.h>
 926 #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x1000100fL
 927 #error "too old"
 928 #endif
 929    ]], [[]])],
 930    [ : ],
 931    [ AC_MSG_ERROR([OpenSSL is too old. We require 1.0.1 or later. You can specify a path to a newer one with --with-openssl-dir.]) ])
 932
 933 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 934 #include <openssl/opensslv.h>
 935 #include <openssl/evp.h>
 936 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_ECDSA)
 937 #error "no ECC"
 938 #endif
 939 #if !defined(NID_X9_62_prime256v1) || !defined(NID_secp224r1)
 940 #error "curves unavailable"
 941 #endif
 942    ]], [[]])],
 943    [ : ],
 944    [ AC_MSG_ERROR([OpenSSL is built without full ECC support, including curves P256 and P224. You can specify a path to one with ECC support with --with-openssl-dir.]) ])
 945
 946 AC_CHECK_MEMBERS([struct ssl_method_st.get_cipher_by_char], , ,
 947 [#include <openssl/ssl.h>
 948 ])
 949
 950 AC_CHECK_FUNCS([ \
 951                 ERR_load_KDF_strings \
 952                 SSL_SESSION_get_master_key \
 953                 SSL_get_server_random \
 954                 SSL_get_client_ciphers \
 955                 SSL_get_client_random \
 956                 SSL_CTX_set1_groups_list \
 957                 SSL_CIPHER_find \
 958                 SSL_CTX_set_security_level \
 959                 TLS_method
 960                ])
 961
 962 dnl Check if OpenSSL has scrypt implementation.
 963 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
 964
 965 dnl Check if OpenSSL structures are opaque
 966 AC_CHECK_MEMBERS([SSL.state], , ,
 967 [#include <openssl/ssl.h>
 968 ])
 969
 970 AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT()
 971 #include <openssl/sha.h>
 972 ])
 973
 974 fi # enable_nss
 975
 976 dnl ======================================================================
 977 dnl Can we use KIST?
 978
 979 dnl Define the set of checks for KIST scheduler support.
 980 AC_DEFUN([CHECK_KIST_SUPPORT],[
 981   dnl KIST needs struct tcp_info and for certain members to exist.
 982   AC_CHECK_MEMBERS(
 983     [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
 984     , ,[[#include <netinet/tcp.h>]])
 985   dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
 986   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
 987                      #include <linux/sockios.h>
 988                      #ifndef SIOCOUTQNSD
 989                      #error
 990                      #endif
 991                      ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
 992   if test "x$have_siocoutqnsd" = "xyes"; then
 993     if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
 994       if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
 995         have_kist_support=yes
 996       fi
 997     fi
 998   fi
 999 ])
1000 dnl Now, trigger the check.
1001 CHECK_KIST_SUPPORT
1002 AS_IF([test "x$have_kist_support" = "xyes"],
1003       [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
1004                                         on this system])],
1005       [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
1006
1007 LIBS="$save_LIBS"
1008 LDFLAGS="$save_LDFLAGS"
1009 CPPFLAGS="$save_CPPFLAGS"
1010
1011 dnl ------------------------------------------------------
1012 dnl Where do you live, zlib?  And how do we call you?
1013
1014 tor_zlib_pkg_redhat="zlib"
1015 tor_zlib_pkg_debian="zlib1g"
1016 tor_zlib_devpkg_redhat="zlib-devel"
1017 tor_zlib_devpkg_debian="zlib1g-dev"
1018
1019 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
1020     [#include <zlib.h>],
1021     [const char * zlibVersion(void);],
1022     [zlibVersion();], [--with-zlib-dir],
1023     [/opt/zlib])
1024
1025 if test "$enable_static_zlib" = "yes"; then
1026    if test "$tor_cv_library_zlib_dir" = "(system)"; then
1027      AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
1028  using --enable-static-zlib")
1029    else
1030      TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
1031    fi
1032 else
1033      TOR_ZLIB_LIBS="-lz"
1034 fi
1035 AC_SUBST(TOR_ZLIB_LIBS)
1036
1037 dnl ------------------------------------------------------
1038 dnl Where we do we find lzma?
1039
1040 AC_ARG_ENABLE(lzma,
1041       AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
1042       [case "${enableval}" in
1043         "yes") lzma=true ;;
1044         "no")  lzma=false ;;
1045         * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
1046       esac], [lzma=auto])
1047
1048 if test "x$enable_lzma" = "xno"; then
1049     have_lzma=no;
1050 else
1051     PKG_CHECK_MODULES([LZMA],
1052                       [liblzma],
1053                       have_lzma=yes,
1054                       have_lzma=no)
1055
1056     if test "x$have_lzma" = "xno" ; then
1057         AC_MSG_WARN([Unable to find liblzma.])
1058     fi
1059 fi
1060
1061 if test "x$have_lzma" = "xyes"; then
1062     AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
1063     TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
1064     TOR_LZMA_LIBS="${LZMA_LIBS}"
1065 fi
1066 AC_SUBST(TOR_LZMA_CFLAGS)
1067 AC_SUBST(TOR_LZMA_LIBS)
1068
1069 dnl ------------------------------------------------------
1070 dnl Where we do we find zstd?
1071
1072 AC_ARG_ENABLE(zstd,
1073       AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
1074       [case "${enableval}" in
1075         "yes") zstd=true ;;
1076         "no")  zstd=false ;;
1077         * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
1078       esac], [zstd=auto])
1079
1080 if test "x$enable_zstd" = "xno"; then
1081     have_zstd=no;
1082 else
1083     PKG_CHECK_MODULES([ZSTD],
1084                       [libzstd >= 1.1],
1085                       have_zstd=yes,
1086                       have_zstd=no)
1087
1088     if test "x$have_zstd" = "xno" ; then
1089         AC_MSG_WARN([Unable to find libzstd.])
1090     fi
1091 fi
1092
1093 if test "x$have_zstd" = "xyes"; then
1094     AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
1095     TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
1096     TOR_ZSTD_LIBS="${ZSTD_LIBS}"
1097
1098     dnl now check for zstd functions
1099     save_LIBS="$LIBS"
1100     save_CFLAGS="$CFLAGS"
1101     LIBS="$LIBS $ZSTD_LIBS"
1102     CFLAGS="$CFLAGS $ZSTD_CFLAGS"
1103     AC_CHECK_FUNCS(ZSTD_estimateCStreamSize \
1104                    ZSTD_estimateDCtxSize)
1105     LIBS="$save_LIBS"
1106     CFLAGS="$save_CFLAGS"
1107 fi
1108 AC_SUBST(TOR_ZSTD_CFLAGS)
1109 AC_SUBST(TOR_ZSTD_LIBS)
1110
1111 dnl ----------------------------------------------------------------------
1112 dnl Check if libcap is available for capabilities.
1113
1114 tor_cap_pkg_debian="libcap2"
1115 tor_cap_pkg_redhat="libcap"
1116 tor_cap_devpkg_debian="libcap-dev"
1117 tor_cap_devpkg_redhat="libcap-devel"
1118
1119 AC_CHECK_LIB([cap], [cap_init], [],
1120   AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
1121 )
1122 AC_CHECK_FUNCS(cap_set_proc)
1123
1124 dnl ---------------------------------------------------------------------
1125 dnl Now that we know about our major libraries, we can check for compiler
1126 dnl and linker hardening options.  We need to do this with the libraries known,
1127 dnl since sometimes the linker will like an option but not be willing to
1128 dnl use it with a build of a library.
1129
1130 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
1131 all_libs_for_check="$TOR_ZLIB_LIBS $TOR_LIB_MATH $TOR_LIBEVENT_LIBS $TOR_OPENSSL_LIBS $TOR_SYSTEMD_LIBS $TOR_LIB_WS32 $TOR_LIB_GDI $TOR_LIB_USERENV $TOR_CAP_LIBS"
1132
1133 CFLAGS_FTRAPV=
1134 CFLAGS_FWRAPV=
1135 CFLAGS_ASAN=
1136 CFLAGS_UBSAN=
1137
1138
1139 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1140 #if !defined(__clang__)
1141 #error
1142 #endif])], have_clang=yes, have_clang=no)
1143
1144 if test "x$enable_pic" = "xyes"; then
1145     TOR_CHECK_CFLAGS(-fPIC)
1146 fi
1147
1148 if test "x$enable_gcc_hardening" != "xno"; then
1149     CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
1150     if test "x$have_clang" = "xyes"; then
1151         TOR_CHECK_CFLAGS(-Qunused-arguments)
1152     fi
1153     TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
1154     AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
1155     AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1156 m4_ifdef([AS_VAR_IF],[
1157     AS_VAR_IF(can_compile, [yes],
1158         AS_VAR_IF(can_link, [yes],
1159                   [],
1160                   AC_MSG_ERROR([We tried to build with stack protection; it looks like your compiler supports it but your libc does not provide it. Are you missing libssp? (You can --disable-gcc-hardening to ignore this error.)]))
1161         )])
1162     AS_VAR_POPDEF([can_link])
1163     AS_VAR_POPDEF([can_compile])
1164     TOR_CHECK_CFLAGS(-Wstack-protector)
1165     TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1166     if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1167        if test "$enable_pic" != "yes"; then
1168            # If we have already enabled -fPIC, then we don't also need to
1169            # compile with -fPIE...
1170            TOR_CHECK_CFLAGS(-fPIE)
1171        fi
1172        # ... but we want to link our executables with -pie in any case, since
1173        # they're executables, not a library.
1174        TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1175     fi
1176     TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1177 fi
1178
1179 if test "$fragile_hardening" = "yes"; then
1180     TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1181    if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1182       AC_MSG_WARN([The compiler supports -ftrapv, but for some reason I was not able to link with -ftrapv. Are you missing run-time support? Run-time hardening will not work as well as it should.])
1183    fi
1184
1185    if test "$tor_cv_cflags__ftrapv" != "yes"; then
1186      AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1187    fi
1188
1189    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1190     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1191       AC_MSG_ERROR([The compiler supports -fsanitize=address, but for some reason I was not able to link when using it. Are you missing run-time support? With GCC you need libubsan.*, and with Clang you need libclang_rt.ubsan*])
1192     fi
1193
1194    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1195     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1196       AC_MSG_ERROR([The compiler supports -fsanitize=undefined, but for some reason I was not able to link when using it. Are you missing run-time support? With GCC you need libasan.*, and with Clang you need libclang_rt.ubsan*])
1197     fi
1198
1199 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1200 fi
1201
1202 dnl Find the correct libraries to add in order to use the sanitizers.
1203 dnl
1204 dnl When building Rust, Cargo will run the linker with the -nodefaultlibs
1205 dnl option, which will prevent the compiler from linking the sanitizer
1206 dnl libraries it needs.  We need to specify them manually.
1207 dnl
1208 dnl What's more, we need to specify them in a linker script rather than
1209 dnl from build.rs: these options aren't allowed in the cargo:rustc-flags
1210 dnl variable.
1211 RUST_LINKER_OPTIONS=""
1212 if test "x$have_clang" = "xyes"; then
1213         if test "x$CFLAGS_ASAN" != "x"; then
1214                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=$CFLAGS_ASAN -Cdefault-linker-libraries"
1215         fi
1216         if test "x$CFLAGS_UBSAN" != "x"; then
1217                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=$CFLAGS_UBSAN -Cdefault-linker-libraries"
1218         fi
1219 else
1220         if test "x$CFLAGS_ASAN" != "x"; then
1221                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=-fsanitize=address -Cdefault-linker-libraries"
1222         fi
1223         if test "x$CFLAGS_UBSAN" != "x"; then
1224                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=-fsanitize=undefined -Cdefault-linker-libraries"
1225         fi
1226 fi
1227 AC_SUBST(RUST_LINKER_OPTIONS)
1228
1229 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1230 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1231
1232 mulodi_fixes_ftrapv=no
1233 if test "$have_clang" = "yes"; then
1234   saved_CFLAGS="$CFLAGS"
1235   CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1236   AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1237   AC_LINK_IFELSE([
1238       AC_LANG_SOURCE([[
1239           #include <stdint.h>
1240           #include <stdlib.h>
1241           int main(int argc, char **argv)
1242           {
1243             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1244                         * (int64_t)atoi(argv[3]);
1245             return x == 9;
1246           } ]])],
1247           [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1248           [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1249   if test "$ftrapv_can_link" = "no"; then
1250     AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1251     AC_LINK_IFELSE([
1252       AC_LANG_SOURCE([[
1253           #include <stdint.h>
1254           #include <stdlib.h>
1255           int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1256              *overflow=0;
1257              return a;
1258           }
1259           int main(int argc, char **argv)
1260           {
1261             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1262                         * (int64_t)atoi(argv[3]);
1263             return x == 9;
1264           } ]])],
1265           [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1266           [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1267   fi
1268   CFLAGS="$saved_CFLAGS"
1269 fi
1270
1271 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1272
1273 dnl These cflags add bunches of branches, and we haven't been able to
1274 dnl persuade ourselves that they're suitable for code that needs to be
1275 dnl constant time.
1276 AC_SUBST(CFLAGS_BUGTRAP)
1277 dnl These cflags are variant ones sutable for code that needs to be
1278 dnl constant-time.
1279 AC_SUBST(CFLAGS_CONSTTIME)
1280
1281 if test "x$enable_linker_hardening" != "xno"; then
1282     TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1283 fi
1284
1285 # For backtrace support
1286 TOR_CHECK_LDFLAGS(-rdynamic)
1287
1288 dnl ------------------------------------------------------
1289 dnl Now see if we have a -fomit-frame-pointer compiler option.
1290
1291 saved_CFLAGS="$CFLAGS"
1292 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1293 F_OMIT_FRAME_POINTER=''
1294 if test "$saved_CFLAGS" != "$CFLAGS"; then
1295   if test "$fragile_hardening" = "yes"; then
1296     F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1297   fi
1298 fi
1299 CFLAGS="$saved_CFLAGS"
1300 AC_SUBST(F_OMIT_FRAME_POINTER)
1301
1302 dnl ------------------------------------------------------
1303 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1304 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1305 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1306 dnl code will work.
1307 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1308
1309 dnl ============================================================
1310 dnl Check for libseccomp
1311
1312 if test "x$enable_seccomp" != "xno"; then
1313   AC_CHECK_HEADERS([seccomp.h])
1314   AC_SEARCH_LIBS(seccomp_init, [seccomp])
1315 fi
1316
1317 dnl ============================================================
1318 dnl Check for libscrypt
1319
1320 if test "x$enable_libscrypt" != "xno"; then
1321   AC_CHECK_HEADERS([libscrypt.h])
1322   AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1323   AC_CHECK_FUNCS([libscrypt_scrypt])
1324 fi
1325
1326 dnl ============================================================
1327 dnl We need an implementation of curve25519.
1328
1329 dnl set these defaults.
1330 build_curve25519_donna=no
1331 build_curve25519_donna_c64=no
1332 use_curve25519_donna=no
1333 use_curve25519_nacl=no
1334 CURVE25519_LIBS=
1335
1336 dnl The best choice is using curve25519-donna-c64, but that requires
1337 dnl that we
1338 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1339   tor_cv_can_use_curve25519_donna_c64,
1340   [AC_RUN_IFELSE(
1341     [AC_LANG_PROGRAM([dnl
1342       #include <stdint.h>
1343       typedef unsigned uint128_t __attribute__((mode(TI)));
1344   int func(uint64_t a, uint64_t b) {
1345            uint128_t c = ((uint128_t)a) * b;
1346            int ok = ((uint64_t)(c>>96)) == 522859 &&
1347              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1348                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1349                  (((uint64_t)(c))&0xffffffffL) == 0;
1350            return ok;
1351       }
1352   ], [dnl
1353     int ok = func( ((uint64_t)2000000000) * 1000000000,
1354                    ((uint64_t)1234567890) << 24);
1355         return !ok;
1356       ])],
1357   [tor_cv_can_use_curve25519_donna_c64=yes],
1358       [tor_cv_can_use_curve25519_donna_c64=no],
1359   [AC_LINK_IFELSE(
1360         [AC_LANG_PROGRAM([dnl
1361       #include <stdint.h>
1362       typedef unsigned uint128_t __attribute__((mode(TI)));
1363   int func(uint64_t a, uint64_t b) {
1364            uint128_t c = ((uint128_t)a) * b;
1365            int ok = ((uint64_t)(c>>96)) == 522859 &&
1366              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1367                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1368                  (((uint64_t)(c))&0xffffffffL) == 0;
1369            return ok;
1370       }
1371   ], [dnl
1372     int ok = func( ((uint64_t)2000000000) * 1000000000,
1373                  ((uint64_t)1234567890) << 24);
1374         return !ok;
1375       ])],
1376           [tor_cv_can_use_curve25519_donna_c64=cross],
1377       [tor_cv_can_use_curve25519_donna_c64=no])])])
1378
1379 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1380                   nacl/crypto_scalarmult_curve25519.h])
1381
1382 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1383   tor_cv_can_use_curve25519_nacl,
1384   [tor_saved_LIBS="$LIBS"
1385    LIBS="$LIBS -lnacl"
1386    AC_LINK_IFELSE(
1387      [AC_LANG_PROGRAM([dnl
1388        #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1389        #include <crypto_scalarmult_curve25519.h>
1390    #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1391    #include <nacl/crypto_scalarmult_curve25519.h>
1392    #endif
1393        #ifdef crypto_scalarmult_curve25519_ref_BYTES
1394    #error Hey, this is the reference implementation! That's not fast.
1395    #endif
1396      ], [
1397    unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1398      ])], [tor_cv_can_use_curve25519_nacl=yes],
1399      [tor_cv_can_use_curve25519_nacl=no])
1400    LIBS="$tor_saved_LIBS" ])
1401
1402  dnl Okay, now we need to figure out which one to actually use. Fall back
1403  dnl to curve25519-donna.c
1404
1405  if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1406    build_curve25519_donna_c64=yes
1407    use_curve25519_donna=yes
1408  elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1409    use_curve25519_nacl=yes
1410    CURVE25519_LIBS=-lnacl
1411  else
1412    build_curve25519_donna=yes
1413    use_curve25519_donna=yes
1414  fi
1415
1416 if test "x$use_curve25519_donna" = "xyes"; then
1417   AC_DEFINE(USE_CURVE25519_DONNA, 1,
1418             [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1419 fi
1420 if test "x$use_curve25519_nacl" = "xyes"; then
1421   AC_DEFINE(USE_CURVE25519_NACL, 1,
1422             [Defined if we should use a curve25519 from nacl])
1423 fi
1424 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1425   test "x$build_curve25519_donna" = "xyes")
1426 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1427   test "x$build_curve25519_donna_c64" = "xyes")
1428 AC_SUBST(CURVE25519_LIBS)
1429
1430 dnl Make sure to enable support for large off_t if available.
1431 AC_SYS_LARGEFILE
1432
1433 AC_CHECK_HEADERS([errno.h \
1434                   fcntl.h \
1435                   signal.h \
1436                   string.h \
1437                   sys/capability.h \
1438                   sys/fcntl.h \
1439                   sys/stat.h \
1440                   sys/time.h \
1441                   sys/types.h \
1442                   time.h \
1443                   unistd.h \
1444                   arpa/inet.h \
1445                   crt_externs.h \
1446                   execinfo.h \
1447                   gnu/libc-version.h \
1448                   grp.h \
1449                   ifaddrs.h \
1450                   inttypes.h \
1451                   limits.h \
1452                   linux/types.h \
1453                   machine/limits.h \
1454                   malloc.h \
1455                   malloc/malloc.h \
1456                   malloc_np.h \
1457                   netdb.h \
1458                   netinet/in.h \
1459                   netinet/in6.h \
1460                   pwd.h \
1461                   readpassphrase.h \
1462                   stdatomic.h \
1463                   sys/eventfd.h \
1464                   sys/file.h \
1465                   sys/ioctl.h \
1466                   sys/limits.h \
1467                   sys/mman.h \
1468                   sys/param.h \
1469                   sys/prctl.h \
1470                   sys/random.h \
1471                   sys/resource.h \
1472                   sys/select.h \
1473                   sys/socket.h \
1474                   sys/statvfs.h \
1475                   sys/syscall.h \
1476                   sys/sysctl.h \
1477                   sys/syslimits.h \
1478                   sys/time.h \
1479                   sys/types.h \
1480                   sys/un.h \
1481                   sys/utime.h \
1482                   sys/wait.h \
1483                   syslog.h \
1484                   utime.h])
1485
1486 AC_CHECK_HEADERS(sys/param.h)
1487
1488 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1489 [#ifdef HAVE_SYS_TYPES_H
1490 #include <sys/types.h>
1491 #endif
1492 #ifdef HAVE_SYS_SOCKET_H
1493 #include <sys/socket.h>
1494 #endif])
1495 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1496 [#ifdef HAVE_SYS_TYPES_H
1497 #include <sys/types.h>
1498 #endif
1499 #ifdef HAVE_SYS_SOCKET_H
1500 #include <sys/socket.h>
1501 #endif
1502 #ifdef HAVE_NET_IF_H
1503 #include <net/if.h>
1504 #endif
1505 #ifdef HAVE_NETINET_IN_H
1506 #include <netinet/in.h>
1507 #endif])
1508
1509 AC_CHECK_HEADERS(linux/if.h,[],[],
1510 [
1511 #ifdef HAVE_SYS_SOCKET_H
1512 #include <sys/socket.h>
1513 #endif
1514 ])
1515
1516 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1517         linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1518 [#ifdef HAVE_SYS_TYPES_H
1519 #include <sys/types.h>
1520 #endif
1521 #ifdef HAVE_SYS_SOCKET_H
1522 #include <sys/socket.h>
1523 #endif
1524 #ifdef HAVE_LIMITS_H
1525 #include <limits.h>
1526 #endif
1527 #ifdef HAVE_LINUX_TYPES_H
1528 #include <linux/types.h>
1529 #endif
1530 #ifdef HAVE_NETINET_IN6_H
1531 #include <netinet/in6.h>
1532 #endif
1533 #ifdef HAVE_NETINET_IN_H
1534 #include <netinet/in.h>
1535 #endif])
1536
1537 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1538         linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1539 [#ifdef HAVE_SYS_TYPES_H
1540 #include <sys/types.h>
1541 #endif
1542 #ifdef HAVE_SYS_SOCKET_H
1543 #include <sys/socket.h>
1544 #endif
1545 #ifdef HAVE_LIMITS_H
1546 #include <limits.h>
1547 #endif
1548 #ifdef HAVE_LINUX_TYPES_H
1549 #include <linux/types.h>
1550 #endif
1551 #ifdef HAVE_NETINET_IN6_H
1552 #include <netinet/in6.h>
1553 #endif
1554 #ifdef HAVE_NETINET_IN_H
1555 #include <netinet/in.h>
1556 #endif
1557 #ifdef HAVE_LINUX_IF_H
1558 #include <linux/if.h>
1559 #endif])
1560
1561 transparent_ok=0
1562 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1563   transparent_ok=1
1564 fi
1565 if test "x$linux_netfilter_ipv4" = "x1"; then
1566   transparent_ok=1
1567 fi
1568 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1569   transparent_ok=1
1570 fi
1571 if test "x$transparent_ok" = "x1"; then
1572   AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1573 else
1574   AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1575 fi
1576
1577 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1578 [#ifdef HAVE_SYS_TYPES_H
1579 #include <sys/types.h>
1580 #endif
1581 #ifdef HAVE_SYS_TIME_H
1582 #include <sys/time.h>
1583 #endif])
1584
1585 AC_CHECK_SIZEOF(char)
1586 AC_CHECK_SIZEOF(short)
1587 AC_CHECK_SIZEOF(int)
1588 AC_CHECK_SIZEOF(long)
1589 AC_CHECK_SIZEOF(long long)
1590 AC_CHECK_SIZEOF(__int64)
1591 AC_CHECK_SIZEOF(void *)
1592 AC_CHECK_SIZEOF(time_t)
1593 AC_CHECK_SIZEOF(size_t)
1594 AC_CHECK_SIZEOF(pid_t)
1595
1596 AC_CHECK_TYPES([uint, u_char, ssize_t])
1597
1598 AC_PC_FROM_UCONTEXT([:])
1599
1600 dnl used to include sockaddr_storage, but everybody has that.
1601 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1602 [#ifdef HAVE_SYS_TYPES_H
1603 #include <sys/types.h>
1604 #endif
1605 #ifdef HAVE_NETINET_IN_H
1606 #include <netinet/in.h>
1607 #endif
1608 #ifdef HAVE_NETINET_IN6_H
1609 #include <netinet/in6.h>
1610 #endif
1611 #ifdef HAVE_SYS_SOCKET_H
1612 #include <sys/socket.h>
1613 #endif
1614 #ifdef _WIN32
1615 #define _WIN32_WINNT 0x0501
1616 #define WIN32_LEAN_AND_MEAN
1617 #include <winsock2.h>
1618 #include <ws2tcpip.h>
1619 #endif
1620 ])
1621 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1622 [#ifdef HAVE_SYS_TYPES_H
1623 #include <sys/types.h>
1624 #endif
1625 #ifdef HAVE_NETINET_IN_H
1626 #include <netinet/in.h>
1627 #endif
1628 #ifdef HAVE_NETINET_IN6_H
1629 #include <netinet/in6.h>
1630 #endif
1631 #ifdef HAVE_SYS_SOCKET_H
1632 #include <sys/socket.h>
1633 #endif
1634 #ifdef _WIN32
1635 #define _WIN32_WINNT 0x0501
1636 #define WIN32_LEAN_AND_MEAN
1637 #include <winsock2.h>
1638 #include <ws2tcpip.h>
1639 #endif
1640 ])
1641
1642 AC_CHECK_TYPES([rlim_t], , ,
1643 [#ifdef HAVE_SYS_TYPES_H
1644 #include <sys/types.h>
1645 #endif
1646 #ifdef HAVE_SYS_TIME_H
1647 #include <sys/time.h>
1648 #endif
1649 #ifdef HAVE_SYS_RESOURCE_H
1650 #include <sys/resource.h>
1651 #endif
1652 ])
1653
1654 AX_CHECK_SIGN([time_t],
1655        [ : ],
1656        [ : ], [
1657 #ifdef HAVE_SYS_TYPES_H
1658 #include <sys/types.h>
1659 #endif
1660 #ifdef HAVE_SYS_TIME_H
1661 #include <sys/time.h>
1662 #endif
1663 #ifdef HAVE_TIME_H
1664 #include <time.h>
1665 #endif
1666 ])
1667
1668 if test "$ax_cv_decl_time_t_signed" = "no"; then
1669   AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1670 fi
1671
1672 AX_CHECK_SIGN([size_t],
1673        [ tor_cv_size_t_signed=yes ],
1674        [ tor_cv_size_t_signed=no ], [
1675 #ifdef HAVE_SYS_TYPES_H
1676 #include <sys/types.h>
1677 #endif
1678 ])
1679
1680 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1681   AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1682 fi
1683
1684 AX_CHECK_SIGN([enum always],
1685        [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1686        [ : ], [
1687  enum always { AAA, BBB, CCC };
1688 ])
1689
1690 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1691 #ifdef HAVE_SYS_SOCKET_H
1692 #include <sys/socket.h>
1693 #endif
1694 ])
1695
1696 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1697
1698 AC_CHECK_SIZEOF(cell_t)
1699
1700 # Let's see if stdatomic works. (There are some debian clangs that screw it
1701 # up; see Tor bug #26779 and debian bug 903709.)
1702 AC_CACHE_CHECK([whether C11 stdatomic.h actually works],
1703                tor_cv_stdatomic_works,
1704 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1705 #include <stdatomic.h>
1706 struct x { atomic_size_t y; };
1707 void try_atomic_init(struct x *xx)
1708 {
1709   atomic_init(&xx->y, 99);
1710   atomic_fetch_add(&xx->y, 1);
1711 }
1712 ]])], [tor_cv_stdatomic_works=yes], [tor_cv_stdatomic_works=no])])
1713
1714 if test "$tor_cv_stdatomic_works" = "yes"; then
1715    AC_DEFINE(STDATOMIC_WORKS, 1, [Set to 1 if we can compile a simple stdatomic example.])
1716 elif test "$ac_cv_header_stdatomic_h" = "yes"; then
1717    AC_MSG_WARN([Your compiler provides the stdatomic.h header, but it doesn't seem to work.  I'll pretend it isn't there. If you are using Clang on Debian, maybe this is because of https://bugs.debian.org/903709 ])
1718 fi
1719
1720 # Now make sure that NULL can be represented as zero bytes.
1721 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1722 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1723 [[#include <stdlib.h>
1724 #include <string.h>
1725 #include <stdio.h>
1726 #ifdef HAVE_STDDEF_H
1727 #include <stddef.h>
1728 #endif
1729 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1730 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1731        [tor_cv_null_is_zero=yes],
1732        [tor_cv_null_is_zero=no],
1733        [tor_cv_null_is_zero=cross])])
1734
1735 if test "$tor_cv_null_is_zero" = "cross"; then
1736   # Cross-compiling; let's hope that the target isn't raving mad.
1737   AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1738 fi
1739
1740 if test "$tor_cv_null_is_zero" != "no"; then
1741   AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1742             [Define to 1 iff memset(0) sets pointers to NULL])
1743 fi
1744
1745 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1746 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1747 [[#include <stdlib.h>
1748 #include <string.h>
1749 #include <stdio.h>
1750 #ifdef HAVE_STDDEF_H
1751 #include <stddef.h>
1752 #endif
1753 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1754 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1755        [tor_cv_dbl0_is_zero=yes],
1756        [tor_cv_dbl0_is_zero=no],
1757        [tor_cv_dbl0_is_zero=cross])])
1758
1759 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1760   # Cross-compiling; let's hope that the target isn't raving mad.
1761   AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1762 fi
1763
1764 if test "$tor_cv_dbl0_is_zero" != "no"; then
1765   AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1766             [Define to 1 iff memset(0) sets doubles to 0.0])
1767 fi
1768
1769 # And what happens when we malloc zero?
1770 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1771 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1772 [[#include <stdlib.h>
1773 #include <string.h>
1774 #include <stdio.h>
1775 #ifdef HAVE_STDDEF_H
1776 #include <stddef.h>
1777 #endif
1778 int main () { return malloc(0)?0:1; }]])],
1779        [tor_cv_malloc_zero_works=yes],
1780        [tor_cv_malloc_zero_works=no],
1781        [tor_cv_malloc_zero_works=cross])])
1782
1783 if test "$tor_cv_malloc_zero_works" = "cross"; then
1784   # Cross-compiling; let's hope that the target isn't raving mad.
1785   AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1786 fi
1787
1788 if test "$tor_cv_malloc_zero_works" = "yes"; then
1789   AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1790             [Define to 1 iff malloc(0) returns a pointer])
1791 fi
1792
1793 # whether we seem to be in a 2s-complement world.
1794 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1795 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1796 [[int main () { int problem = ((-99) != (~99)+1);
1797 return problem ? 1 : 0; }]])],
1798        [tor_cv_twos_complement=yes],
1799        [tor_cv_twos_complement=no],
1800        [tor_cv_twos_complement=cross])])
1801
1802 if test "$tor_cv_twos_complement" = "cross"; then
1803   # Cross-compiling; let's hope that the target isn't raving mad.
1804   AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1805 fi
1806
1807 if test "$tor_cv_twos_complement" != "no"; then
1808   AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1809             [Define to 1 iff we represent negative integers with
1810              two's complement])
1811 fi
1812
1813 # What does shifting a negative value do?
1814 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1815 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1816 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1817        [tor_cv_sign_extend=yes],
1818        [tor_cv_sign_extend=no],
1819        [tor_cv_sign_extend=cross])])
1820
1821 if test "$tor_cv_sign_extend" = "cross"; then
1822   # Cross-compiling; let's hope that the target isn't raving mad.
1823   AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1824 fi
1825
1826 if test "$tor_cv_sign_extend" != "no"; then
1827   AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1828             [Define to 1 iff right-shifting a negative value performs sign-extension])
1829 fi
1830
1831 # Is uint8_t the same type as unsigned char?
1832 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1833 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1834 #include <stdint.h>
1835 extern uint8_t c;
1836 unsigned char c;]])],
1837        [tor_cv_uint8_uchar=yes],
1838        [tor_cv_uint8_uchar=no],
1839        [tor_cv_uint8_uchar=cross])])
1840
1841 if test "$tor_cv_uint8_uchar" = "cross"; then
1842   AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1843 fi
1844
1845 if test "$tor_cv_uint8_uchar" = "no"; then
1846   AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1847 fi
1848
1849 AC_ARG_WITH(tcmalloc,
1850 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library. Deprecated; see --with-malloc]),
1851 [ tcmalloc=yes ], [ tcmalloc=no ])
1852
1853 default_malloc=system
1854
1855 if test "x$enable_openbsd_malloc" = "xyes" ; then
1856   AC_MSG_NOTICE([The --enable-openbsd-malloc argument is deprecated; use --with-malloc=openbsd instead.])
1857   default_malloc=openbsd
1858 fi
1859
1860 if test "x$tcmalloc" = "xyes"; then
1861   AC_MSG_NOTICE([The --with-tcmalloc argument is deprecated; use --with-malloc=tcmalloc instead.])
1862   default_malloc=tcmalloc
1863 fi
1864
1865 AC_ARG_WITH(malloc,
1866    AS_HELP_STRING([--with-malloc=[system,jemalloc,tcmalloc,openbsd]],
1867                   [select special malloc implementation [system]]),
1868    [ malloc="$with_malloc" ], [ malloc="$default_malloc" ])
1869
1870 AS_CASE([$malloc],
1871   [tcmalloc], [
1872       PKG_CHECK_MODULES([TCMALLOC],
1873                         [libtcmalloc],
1874                         have_tcmalloc=yes,
1875                         have_tcmalloc=no)
1876
1877       if test "x$have_tcmalloc" = "xno" ; then
1878           AC_MSG_ERROR([Unable to find tcmalloc requested by --with-malloc.])
1879       fi
1880
1881       CFLAGS="$CFLAGS $TCMALLOC_CFLAGS"
1882       LIBS="$TCMALLOC_LIBS $LIBS"
1883   ],
1884
1885   [jemalloc], [
1886       PKG_CHECK_MODULES([JEMALLOC],
1887                         [jemalloc],
1888                         have_jemalloc=yes,
1889                         have_jemalloc=no)
1890
1891       if test "x$have_tcmalloc" = "xno" ; then
1892           AC_MSG_ERROR([Unable to find jemalloc requested by --with-malloc.])
1893       fi
1894
1895       CFLAGS="$CFLAGS $JEMALLOC_CFLAGS"
1896       LIBS="$JEMALLOC_LIBS $LIBS"
1897       using_custom_malloc=yes
1898   ],
1899
1900   [openbsd], [
1901     AC_MSG_WARN([The openbsd malloc port is deprecated in Tor 0.3.5 and will be removed in a future version.])
1902     enable_openbsd_malloc=yes
1903   ],
1904
1905   [system], [
1906      # handle this later, including the jemalloc fallback
1907     AC_CHECK_FUNCS(mallinfo)
1908   ],
1909
1910   [AC_MSG_ERROR([--with-malloc=`$with_malloc' not supported, see --help])
1911 ])
1912
1913 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
1914
1915 if test "$malloc" != "system"; then
1916   # Tell the C compiler not to use the system allocator functions.
1917   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1918 fi
1919 if test "$using_custom_malloc" = "yes"; then
1920   # Tell the C compiler not to use the system allocator functions.
1921   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1922 fi
1923
1924 # By default, we're going to assume we don't have mlockall()
1925 # bionic and other platforms have various broken mlockall subsystems.
1926 # Some systems don't have a working mlockall, some aren't linkable,
1927 # and some have it but don't declare it.
1928 AC_CHECK_FUNCS(mlockall)
1929 AC_CHECK_DECLS([mlockall], , , [
1930 #ifdef HAVE_SYS_MMAN_H
1931 #include <sys/mman.h>
1932 #endif])
1933
1934 # Allow user to specify an alternate syslog facility
1935 AC_ARG_WITH(syslog-facility,
1936 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1937 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1938 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1939 AC_SUBST(LOGFACILITY)
1940
1941 # Check if we have getresuid and getresgid
1942 AC_CHECK_FUNCS(getresuid getresgid)
1943
1944 # Check for gethostbyname_r in all its glorious incompatible versions.
1945 #   (This logic is based on that in Python's configure.in)
1946 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1947   [Define this if you have any gethostbyname_r()])
1948
1949 AC_CHECK_FUNC(gethostbyname_r, [
1950   AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1951   OLD_CFLAGS=$CFLAGS
1952   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1953   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1954 #include <netdb.h>
1955   ]], [[
1956     char *cp1, *cp2;
1957     struct hostent *h1, *h2;
1958     int i1, i2;
1959     (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1960   ]])],[
1961     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1962     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1963      [Define this if gethostbyname_r takes 6 arguments])
1964     AC_MSG_RESULT(6)
1965   ], [
1966     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1967 #include <netdb.h>
1968     ]], [[
1969       char *cp1, *cp2;
1970       struct hostent *h1;
1971       int i1, i2;
1972       (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1973     ]])], [
1974       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1975       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1976         [Define this if gethostbyname_r takes 5 arguments])
1977       AC_MSG_RESULT(5)
1978    ], [
1979       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1980 #include <netdb.h>
1981      ]], [[
1982        char *cp1;
1983        struct hostent *h1;
1984        struct hostent_data hd;
1985        (void) gethostbyname_r(cp1,h1,&hd);
1986      ]])], [
1987        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1988        AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1989          [Define this if gethostbyname_r takes 3 arguments])
1990        AC_MSG_RESULT(3)
1991      ], [
1992        AC_MSG_RESULT(0)
1993      ])
1994   ])
1995  ])
1996  CFLAGS=$OLD_CFLAGS
1997 ])
1998
1999 AC_CACHE_CHECK([whether the C compiler supports __func__],
2000   tor_cv_have_func_macro,
2001   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2002 #include <stdio.h>
2003 int main(int c, char **v) { puts(__func__); }])],
2004   tor_cv_have_func_macro=yes,
2005   tor_cv_have_func_macro=no))
2006
2007 AC_CACHE_CHECK([whether the C compiler supports __FUNC__],
2008   tor_cv_have_FUNC_macro,
2009   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2010 #include <stdio.h>
2011 int main(int c, char **v) { puts(__FUNC__); }])],
2012   tor_cv_have_FUNC_macro=yes,
2013   tor_cv_have_FUNC_macro=no))
2014
2015 AC_CACHE_CHECK([whether the C compiler supports __FUNCTION__],
2016   tor_cv_have_FUNCTION_macro,
2017   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2018 #include <stdio.h>
2019 int main(int c, char **v) { puts(__FUNCTION__); }])],
2020   tor_cv_have_FUNCTION_macro=yes,
2021   tor_cv_have_FUNCTION_macro=no))
2022
2023 AC_CACHE_CHECK([whether we have extern char **environ already declared],
2024   tor_cv_have_environ_declared,
2025   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2026 #ifdef HAVE_UNISTD_H
2027 #include <unistd.h>
2028 #endif
2029 #include <stdlib.h>
2030 int main(int c, char **v) { char **t = environ; }])],
2031   tor_cv_have_environ_declared=yes,
2032   tor_cv_have_environ_declared=no))
2033
2034 if test "$tor_cv_have_func_macro" = "yes"; then
2035   AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
2036 fi
2037
2038 if test "$tor_cv_have_FUNC_macro" = "yes"; then
2039   AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
2040 fi
2041
2042 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
2043   AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
2044            [Defined if the compiler supports __FUNCTION__])
2045 fi
2046
2047 if test "$tor_cv_have_environ_declared" = "yes"; then
2048   AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
2049            [Defined if we have extern char **environ already declared])
2050 fi
2051
2052 # $prefix stores the value of the --prefix command line option, or
2053 # NONE if the option wasn't set.  In the case that it wasn't set, make
2054 # it be the default, so that we can use it to expand directories now.
2055 if test "x$prefix" = "xNONE"; then
2056   prefix=$ac_default_prefix
2057 fi
2058
2059 # and similarly for $exec_prefix
2060 if test "x$exec_prefix" = "xNONE"; then
2061   exec_prefix=$prefix
2062 fi
2063
2064 if test "x$BUILDDIR" = "x"; then
2065   BUILDDIR=`pwd`
2066 fi
2067 AC_SUBST(BUILDDIR)
2068 AH_TEMPLATE([BUILDDIR],[tor's build directory])
2069 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
2070
2071 if test "x$SRCDIR" = "x"; then
2072   SRCDIR=$(cd "$srcdir"; pwd)
2073 fi
2074 AH_TEMPLATE([SRCDIR],[tor's sourcedir directory])
2075 AC_DEFINE_UNQUOTED(SRCDIR,"$SRCDIR")
2076
2077 if test "x$CONFDIR" = "x"; then
2078   CONFDIR=`eval echo $sysconfdir/tor`
2079 fi
2080 AC_SUBST(CONFDIR)
2081 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
2082 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
2083
2084 BINDIR=`eval echo $bindir`
2085 AC_SUBST(BINDIR)
2086 LOCALSTATEDIR=`eval echo $localstatedir`
2087 AC_SUBST(LOCALSTATEDIR)
2088
2089 if test "$bwin32" = "true"; then
2090   # Test if the linker supports the --nxcompat and --dynamicbase options
2091   # for Windows
2092   save_LDFLAGS="$LDFLAGS"
2093   LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
2094   AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
2095   AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
2096     [AC_MSG_RESULT([yes])]
2097     [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
2098     [AC_MSG_RESULT([no])]
2099   )
2100   LDFLAGS="$save_LDFLAGS"
2101 fi
2102
2103 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
2104 # than autoconf's macros like.
2105 if test "$GCC" = "yes"; then
2106   # Disable GCC's strict aliasing checks.  They are an hours-to-debug
2107   # accident waiting to happen.
2108   CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
2109 else
2110   # Override optimization level for non-gcc compilers
2111   CFLAGS="$CFLAGS -O"
2112   enable_gcc_warnings=no
2113   enable_gcc_warnings_advisory=no
2114 fi
2115
2116 # Warnings implies advisory-warnings and -Werror.
2117 if test "$enable_gcc_warnings" = "yes"; then
2118   enable_gcc_warnings_advisory=yes
2119   enable_fatal_warnings=yes
2120 fi
2121
2122 # OS X Lion started deprecating the system openssl. Let's just disable
2123 # all deprecation warnings on OS X. Also, to potentially make the binary
2124 # a little smaller, let's enable dead_strip.
2125 case "$host_os" in
2126
2127  darwin*)
2128     CFLAGS="$CFLAGS -Wno-deprecated-declarations"
2129     LDFLAGS="$LDFLAGS -dead_strip" ;;
2130 esac
2131
2132 TOR_WARNING_FLAGS=""
2133
2134 # Add some more warnings which we use in development but not in the
2135 # released versions.  (Some relevant gcc versions can't handle these.)
2136 #
2137 # Note that we have to do this near the end  of the autoconf process, or
2138 # else we may run into problems when these warnings hit on the testing C
2139 # programs that autoconf wants to build.
2140 if test "x$enable_gcc_warnings_advisory" != "xno"; then
2141
2142   case "$host" in
2143     *-*-openbsd* | *-*-bitrig*)
2144       # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
2145       # That's fine, except that the headers don't pass -Wredundant-decls.
2146       # Therefore, let's disable -Wsystem-headers when we're building
2147       # with maximal warnings on OpenBSD.
2148       CFLAGS="$CFLAGS -Wno-system-headers" ;;
2149   esac
2150
2151   CFLAGS_NOWARNINGS="$CFLAGS"
2152
2153   # GCC4.3 users once report trouble with -Wstrict-overflow=5.  GCC5 users
2154   # have it work better.
2155   # CFLAGS="$CFLAGS -Wstrict-overflow=1"
2156
2157   # This warning was added in gcc 4.3, but it appears to generate
2158   # spurious warnings in gcc 4.4.  I don't know if it works in 4.5.
2159   #CFLAGS="$CFLAGS -Wlogical-op"
2160
2161   m4_foreach_w([warning_flag], [
2162      -Waddress
2163      -Waddress-of-array-temporary
2164      -Waddress-of-temporary
2165      -Wambiguous-macro
2166      -Wanonymous-pack-parens
2167      -Warc
2168      -Warc-abi
2169      -Warc-bridge-casts-disallowed-in-nonarc
2170      -Warc-maybe-repeated-use-of-weak
2171      -Warc-performSelector-leaks
2172      -Warc-repeated-use-of-weak
2173      -Warray-bounds
2174      -Warray-bounds-pointer-arithmetic
2175      -Wasm
2176      -Wasm-operand-widths
2177      -Watomic-properties
2178      -Watomic-property-with-user-defined-accessor
2179      -Wauto-import
2180      -Wauto-storage-class
2181      -Wauto-var-id
2182      -Wavailability
2183      -Wbackslash-newline-escape
2184      -Wbad-array-new-length
2185      -Wbind-to-temporary-copy
2186      -Wbitfield-constant-conversion
2187      -Wbool-conversion
2188      -Wbool-conversions
2189      -Wbuiltin-requires-header
2190      -Wchar-align
2191      -Wcompare-distinct-pointer-types
2192      -Wcomplex-component-init
2193      -Wconditional-type-mismatch
2194      -Wconfig-macros
2195      -Wconstant-conversion
2196      -Wconstant-logical-operand
2197      -Wconstexpr-not-const
2198      -Wcustom-atomic-properties
2199      -Wdangling-field
2200      -Wdangling-initializer-list
2201      -Wdate-time
2202      -Wdelegating-ctor-cycles
2203      -Wdeprecated-implementations
2204      -Wdeprecated-register
2205      -Wdirect-ivar-access
2206      -Wdiscard-qual
2207      -Wdistributed-object-modifiers
2208      -Wdivision-by-zero
2209      -Wdollar-in-identifier-extension
2210      -Wdouble-promotion
2211      -Wduplicate-decl-specifier
2212      -Wduplicate-enum
2213      -Wduplicate-method-arg
2214      -Wduplicate-method-match
2215      -Wduplicated-cond
2216      -Wdynamic-class-memaccess
2217      -Wembedded-directive
2218      -Wempty-translation-unit
2219      -Wenum-conversion
2220      -Wexit-time-destructors
2221      -Wexplicit-ownership-type
2222      -Wextern-initializer
2223      -Wextra
2224      -Wextra-semi
2225      -Wextra-tokens
2226      -Wflexible-array-extensions
2227      -Wfloat-conversion
2228      -Wformat-non-iso
2229      -Wfour-char-constants
2230      -Wgcc-compat
2231      -Wglobal-constructors
2232      -Wgnu-array-member-paren-init
2233      -Wgnu-designator
2234      -Wgnu-static-float-init
2235      -Wheader-guard
2236      -Wheader-hygiene
2237      -Widiomatic-parentheses
2238      -Wignored-attributes
2239      -Wimplicit-atomic-properties
2240      -Wimplicit-conversion-floating-point-to-bool
2241      -Wimplicit-exception-spec-mismatch
2242      -Wimplicit-fallthrough
2243      -Wimplicit-fallthrough-per-function
2244      -Wimplicit-retain-self
2245      -Wimport-preprocessor-directive-pedantic
2246      -Wincompatible-library-redeclaration
2247      -Wincompatible-pointer-types-discards-qualifiers
2248      -Wincomplete-implementation
2249      -Wincomplete-module
2250      -Wincomplete-umbrella
2251      -Winit-self
2252      -Wint-conversions
2253      -Wint-to-void-pointer-cast
2254      -Winteger-overflow
2255      -Winvalid-constexpr
2256      -Winvalid-iboutlet
2257      -Winvalid-noreturn
2258      -Winvalid-pp-token
2259      -Winvalid-source-encoding
2260      -Winvalid-token-paste
2261      -Wknr-promoted-parameter
2262      -Wlarge-by-value-copy
2263      -Wliteral-conversion
2264      -Wliteral-range
2265      -Wlocal-type-template-args
2266      -Wlogical-op
2267      -Wloop-analysis
2268      -Wmain-return-type
2269      -Wmalformed-warning-check
2270      -Wmethod-signatures
2271      -Wmicrosoft
2272      -Wmicrosoft-exists
2273      -Wmismatched-parameter-types
2274      -Wmismatched-return-types
2275      -Wmissing-field-initializers
2276      -Wmissing-format-attribute
2277      -Wmissing-noreturn
2278      -Wmissing-selector-name
2279      -Wmissing-sysroot
2280      -Wmissing-variable-declarations
2281      -Wmodule-conflict
2282      -Wnested-anon-types
2283      -Wnewline-eof
2284      -Wnon-literal-null-conversion
2285      -Wnon-pod-varargs
2286      -Wnonportable-cfstrings
2287      -Wnormalized=nfkc
2288      -Wnull-arithmetic
2289      -Wnull-character
2290      -Wnull-conversion
2291      -Wnull-dereference
2292      -Wout-of-line-declaration
2293      -Wover-aligned
2294      -Woverlength-strings
2295      -Woverride-init
2296      -Woverriding-method-mismatch
2297      -Wpointer-type-mismatch
2298      -Wpredefined-identifier-outside-function
2299      -Wprotocol-property-synthesis-ambiguity
2300      -Wreadonly-iboutlet-property
2301      -Wreadonly-setter-attrs
2302      -Wreceiver-expr
2303      -Wreceiver-forward-class
2304      -Wreceiver-is-weak
2305      -Wreinterpret-base-class
2306      -Wrequires-super-attribute
2307      -Wreserved-user-defined-literal
2308      -Wreturn-stack-address
2309      -Wsection
2310      -Wselector-type-mismatch
2311      -Wsentinel
2312      -Wserialized-diagnostics
2313      -Wshadow
2314      -Wshift-count-negative
2315      -Wshift-count-overflow
2316      -Wshift-negative-value
2317      -Wshift-overflow=2
2318      -Wshift-sign-overflow
2319      -Wshorten-64-to-32
2320      -Wsizeof-array-argument
2321      -Wsource-uses-openmp
2322      -Wstatic-float-init
2323      -Wstatic-in-inline
2324      -Wstatic-local-in-inline
2325      -Wstrict-overflow=1
2326      -Wstring-compare
2327      -Wstring-conversion
2328      -Wstrlcpy-strlcat-size
2329      -Wstrncat-size
2330      -Wsuggest-attribute=format
2331      -Wsuggest-attribute=noreturn
2332      -Wsuper-class-method-mismatch
2333      -Wswitch-bool
2334      -Wsync-nand
2335      -Wtautological-constant-out-of-range-compare
2336      -Wtentative-definition-incomplete-type
2337      -Wtrampolines
2338      -Wtype-safety
2339      -Wtypedef-redefinition
2340      -Wtypename-missing
2341      -Wundefined-inline
2342      -Wundefined-internal
2343      -Wundefined-reinterpret-cast
2344      -Wunicode
2345      -Wunicode-whitespace
2346      -Wunknown-warning-option
2347      -Wunnamed-type-template-args
2348      -Wunneeded-member-function
2349      -Wunsequenced
2350      -Wunsupported-visibility
2351      -Wunused-but-set-parameter
2352      -Wunused-but-set-variable
2353      -Wunused-command-line-argument
2354      -Wunused-const-variable=2
2355      -Wunused-exception-parameter
2356      -Wunused-local-typedefs
2357      -Wunused-member-function
2358      -Wunused-sanitize-argument
2359      -Wunused-volatile-lvalue
2360      -Wuser-defined-literals
2361      -Wvariadic-macros
2362      -Wvector-conversion
2363      -Wvector-conversions
2364      -Wvexing-parse
2365      -Wvisibility
2366      -Wvla-extension
2367      -Wzero-length-array
2368   ], [ TOR_TRY_COMPILE_WITH_CFLAGS(warning_flag, [],
2369               [TOR_WARNING_FLAGS="$TOR_WARNING_FLAGS warning_flag" CFLAGS="$CFLAGS warning_flag"], true)
2370      ])
2371
2372 dnl    We should re-enable this in some later version.  Clang doesn't
2373 dnl    mind, but it causes trouble with GCC.
2374 dnl     -Wstrict-overflow=2
2375
2376 dnl    These seem to require annotations that we don't currently use,
2377 dnl    and they give false positives in our pthreads wrappers. (Clang 4)
2378 dnl     -Wthread-safety
2379 dnl     -Wthread-safety-analysis
2380 dnl     -Wthread-safety-attributes
2381 dnl     -Wthread-safety-beta
2382 dnl     -Wthread-safety-precise
2383
2384   W_FLAGS="$W_FLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2385   W_FLAGS="$W_FLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2386   W_FLAGS="$W_FLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2387   W_FLAGS="$W_FLAGS -Wwrite-strings"
2388   W_FLAGS="$W_FLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2389   W_FLAGS="$W_FLAGS -Waggregate-return -Wpacked -Wunused"
2390   W_FLAGS="$W_FLAGS -Wunused-parameter "
2391   # These interfere with building main() { return 0; }, which autoconf
2392   # likes to use as its default program.
2393   W_FLAGS="$W_FLAGS -Wold-style-definition -Wmissing-declarations"
2394
2395   TOR_WARNING_FLAGS="$TOR_WARNING_FLAGS $W_FLAGS"
2396   CFLAGS="$CFLAGS $W_FLAGS"
2397
2398   if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2399     AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2400   fi
2401   if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2402     AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2403   fi
2404   if test "$tor_cv_cflags__warn_unused_const_variable_2" = "yes"; then
2405     AC_DEFINE([HAVE_CFLAG_WUNUSED_CONST_VARIABLE], 1, [True if we have -Wunused-const-variable])
2406   fi
2407
2408   CFLAGS="$CFLAGS_NOWARNINGS"
2409
2410   if test "x$enable_fatal_warnings" = "xyes"; then
2411     # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2412     # default autoconf programs are full of errors.
2413     CFLAGS="$CFLAGS -Werror"
2414   fi
2415
2416 fi
2417
2418 AC_SUBST(TOR_WARNING_FLAGS)
2419
2420 echo "$TOR_WARNING_FLAGS">warning_flags
2421
2422 TOR_TRY_COMPILE_WITH_CFLAGS([@warning_flags], [],
2423                             CFLAGS="$CFLAGS @warning_flags",
2424                             CFLAGS="$CFLAGS $TOR_WARNING_FLAGS")
2425
2426 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2427    case "$host_os" in
2428     darwin*)
2429       AC_MSG_WARN([Tried to enable coverage on OSX without using the clang compiler. This might not work! If coverage fails, use CC=clang when configuring with --enable-coverage.])
2430    esac
2431 fi
2432
2433 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2434
2435 AC_CONFIG_FILES([
2436         Doxyfile
2437         Makefile
2438         config.rust
2439         contrib/dist/suse/tor.sh
2440         contrib/operator-tools/tor.logrotate
2441         contrib/dist/tor.sh
2442         contrib/dist/torctl
2443         contrib/dist/tor.service
2444         src/config/torrc.sample
2445         src/config/torrc.minimal
2446         src/rust/.cargo/config
2447         scripts/maint/checkOptionDocs.pl
2448         scripts/maint/updateVersions.pl
2449         warning_flags
2450 ])
2451
2452 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2453   regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2454   for file in $regular_mans ; do
2455     if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2456       echo "==================================";
2457       echo;
2458       echo "Building Tor has failed since manpages cannot be built.";
2459       echo;
2460       echo "You need asciidoc installed to be able to build the manpages.";
2461       echo "To build without manpages, use the --disable-asciidoc argument";
2462       echo "when calling configure.";
2463       echo;
2464       echo "==================================";
2465       exit 1;
2466     fi
2467   done
2468 fi
2469
2470 if test "$fragile_hardening" = "yes"; then
2471   AC_MSG_WARN([
2472
2473 ============
2474 Warning!  Building Tor with --enable-fragile-hardening (also known as
2475 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2476 other kinds of attacks easier. A Tor instance build with this option will be
2477 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2478 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2479 denial of service attacks. For more information, see
2480 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening
2481 ============
2482   ])
2483 fi
2484
2485 AC_OUTPUT