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-2018, The Tor Project, Inc.
   4 dnl See LICENSE for licensing information
   5
   6 AC_PREREQ([2.63])
   7 AC_INIT([tor],[0.3.5.0-alpha-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_CIPHER_find \
 957                 SSL_CTX_set_security_level \
 958                 TLS_method
 959                ])
 960
 961 dnl Check if OpenSSL has scrypt implementation.
 962 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
 963
 964 dnl Check if OpenSSL structures are opaque
 965 AC_CHECK_MEMBERS([SSL.state], , ,
 966 [#include <openssl/ssl.h>
 967 ])
 968
 969 AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT()
 970 #include <openssl/sha.h>
 971 ])
 972
 973 fi # enable_nss
 974
 975 dnl ======================================================================
 976 dnl Can we use KIST?
 977
 978 dnl Define the set of checks for KIST scheduler support.
 979 AC_DEFUN([CHECK_KIST_SUPPORT],[
 980   dnl KIST needs struct tcp_info and for certain members to exist.
 981   AC_CHECK_MEMBERS(
 982     [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
 983     , ,[[#include <netinet/tcp.h>]])
 984   dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
 985   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
 986                      #include <linux/sockios.h>
 987                      #ifndef SIOCOUTQNSD
 988                      #error
 989                      #endif
 990                      ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
 991   if test "x$have_siocoutqnsd" = "xyes"; then
 992     if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
 993       if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
 994         have_kist_support=yes
 995       fi
 996     fi
 997   fi
 998 ])
 999 dnl Now, trigger the check.
1000 CHECK_KIST_SUPPORT
1001 AS_IF([test "x$have_kist_support" = "xyes"],
1002       [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
1003                                         on this system])],
1004       [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
1005
1006 LIBS="$save_LIBS"
1007 LDFLAGS="$save_LDFLAGS"
1008 CPPFLAGS="$save_CPPFLAGS"
1009
1010 dnl ------------------------------------------------------
1011 dnl Where do you live, zlib?  And how do we call you?
1012
1013 tor_zlib_pkg_redhat="zlib"
1014 tor_zlib_pkg_debian="zlib1g"
1015 tor_zlib_devpkg_redhat="zlib-devel"
1016 tor_zlib_devpkg_debian="zlib1g-dev"
1017
1018 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
1019     [#include <zlib.h>],
1020     [const char * zlibVersion(void);],
1021     [zlibVersion();], [--with-zlib-dir],
1022     [/opt/zlib])
1023
1024 if test "$enable_static_zlib" = "yes"; then
1025    if test "$tor_cv_library_zlib_dir" = "(system)"; then
1026      AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
1027  using --enable-static-zlib")
1028    else
1029      TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
1030    fi
1031 else
1032      TOR_ZLIB_LIBS="-lz"
1033 fi
1034 AC_SUBST(TOR_ZLIB_LIBS)
1035
1036 dnl ------------------------------------------------------
1037 dnl Where we do we find lzma?
1038
1039 AC_ARG_ENABLE(lzma,
1040       AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
1041       [case "${enableval}" in
1042         "yes") lzma=true ;;
1043         "no")  lzma=false ;;
1044         * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
1045       esac], [lzma=auto])
1046
1047 if test "x$enable_lzma" = "xno"; then
1048     have_lzma=no;
1049 else
1050     PKG_CHECK_MODULES([LZMA],
1051                       [liblzma],
1052                       have_lzma=yes,
1053                       have_lzma=no)
1054
1055     if test "x$have_lzma" = "xno" ; then
1056         AC_MSG_WARN([Unable to find liblzma.])
1057     fi
1058 fi
1059
1060 if test "x$have_lzma" = "xyes"; then
1061     AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
1062     TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
1063     TOR_LZMA_LIBS="${LZMA_LIBS}"
1064 fi
1065 AC_SUBST(TOR_LZMA_CFLAGS)
1066 AC_SUBST(TOR_LZMA_LIBS)
1067
1068 dnl ------------------------------------------------------
1069 dnl Where we do we find zstd?
1070
1071 AC_ARG_ENABLE(zstd,
1072       AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
1073       [case "${enableval}" in
1074         "yes") zstd=true ;;
1075         "no")  zstd=false ;;
1076         * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
1077       esac], [zstd=auto])
1078
1079 if test "x$enable_zstd" = "xno"; then
1080     have_zstd=no;
1081 else
1082     PKG_CHECK_MODULES([ZSTD],
1083                       [libzstd >= 1.1],
1084                       have_zstd=yes,
1085                       have_zstd=no)
1086
1087     if test "x$have_zstd" = "xno" ; then
1088         AC_MSG_WARN([Unable to find libzstd.])
1089     fi
1090 fi
1091
1092 if test "x$have_zstd" = "xyes"; then
1093     AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
1094     TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
1095     TOR_ZSTD_LIBS="${ZSTD_LIBS}"
1096
1097     dnl now check for zstd functions
1098     save_LIBS="$LIBS"
1099     save_CFLAGS="$CFLAGS"
1100     LIBS="$LIBS $ZSTD_LIBS"
1101     CFLAGS="$CFLAGS $ZSTD_CFLAGS"
1102     AC_CHECK_FUNCS(ZSTD_estimateCStreamSize \
1103                    ZSTD_estimateDCtxSize)
1104     LIBS="$save_LIBS"
1105     CFLAGS="$save_CFLAGS"
1106 fi
1107 AC_SUBST(TOR_ZSTD_CFLAGS)
1108 AC_SUBST(TOR_ZSTD_LIBS)
1109
1110 dnl ----------------------------------------------------------------------
1111 dnl Check if libcap is available for capabilities.
1112
1113 tor_cap_pkg_debian="libcap2"
1114 tor_cap_pkg_redhat="libcap"
1115 tor_cap_devpkg_debian="libcap-dev"
1116 tor_cap_devpkg_redhat="libcap-devel"
1117
1118 AC_CHECK_LIB([cap], [cap_init], [],
1119   AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
1120 )
1121 AC_CHECK_FUNCS(cap_set_proc)
1122
1123 dnl ---------------------------------------------------------------------
1124 dnl Now that we know about our major libraries, we can check for compiler
1125 dnl and linker hardening options.  We need to do this with the libraries known,
1126 dnl since sometimes the linker will like an option but not be willing to
1127 dnl use it with a build of a library.
1128
1129 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
1130 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"
1131
1132 CFLAGS_FTRAPV=
1133 CFLAGS_FWRAPV=
1134 CFLAGS_ASAN=
1135 CFLAGS_UBSAN=
1136
1137
1138 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1139 #if !defined(__clang__)
1140 #error
1141 #endif])], have_clang=yes, have_clang=no)
1142
1143 if test "x$enable_pic" = "xyes"; then
1144     TOR_CHECK_CFLAGS(-fPIC)
1145 fi
1146
1147 if test "x$enable_gcc_hardening" != "xno"; then
1148     CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
1149     if test "x$have_clang" = "xyes"; then
1150         TOR_CHECK_CFLAGS(-Qunused-arguments)
1151     fi
1152     TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
1153     AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
1154     AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1155 m4_ifdef([AS_VAR_IF],[
1156     AS_VAR_IF(can_compile, [yes],
1157         AS_VAR_IF(can_link, [yes],
1158                   [],
1159                   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.)]))
1160         )])
1161     AS_VAR_POPDEF([can_link])
1162     AS_VAR_POPDEF([can_compile])
1163     TOR_CHECK_CFLAGS(-Wstack-protector)
1164     TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1165     if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1166        if test "$enable_pic" != "yes"; then
1167            # If we have already enabled -fPIC, then we don't also need to
1168            # compile with -fPIE...
1169            TOR_CHECK_CFLAGS(-fPIE)
1170        fi
1171        # ... but we want to link our executables with -pie in any case, since
1172        # they're executables, not a library.
1173        TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1174     fi
1175     TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1176 fi
1177
1178 if test "$fragile_hardening" = "yes"; then
1179     TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1180    if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1181       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.])
1182    fi
1183
1184    if test "$tor_cv_cflags__ftrapv" != "yes"; then
1185      AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1186    fi
1187
1188    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1189     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1190       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*])
1191     fi
1192
1193    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1194     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1195       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*])
1196     fi
1197
1198 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1199 fi
1200
1201 dnl Find the correct libraries to add in order to use the sanitizers.
1202 dnl
1203 dnl When building Rust, Cargo will run the linker with the -nodefaultlibs
1204 dnl option, which will prevent the compiler from linking the sanitizer
1205 dnl libraries it needs.  We need to specify them manually.
1206 dnl
1207 dnl What's more, we need to specify them in a linker script rather than
1208 dnl from build.rs: these options aren't allowed in the cargo:rustc-flags
1209 dnl variable.
1210 RUST_LINKER_OPTIONS=""
1211 if test "x$have_clang" = "xyes"; then
1212         if test "x$CFLAGS_ASAN" != "x"; then
1213                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS $CFLAGS_ASAN"
1214         fi
1215         if test "x$CFLAGS_UBSAN" != "x"; then
1216                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS $CFLAGS_UBSAN"
1217         fi
1218 else
1219         if test "x$CFLAGS_ASAN" != "x"; then
1220                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -lasan"
1221         fi
1222         if test "x$CFLAGS_UBSAN" != "x"; then
1223                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -lubsan"
1224         fi
1225 fi
1226 AC_SUBST(RUST_LINKER_OPTIONS)
1227
1228 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1229 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1230
1231 mulodi_fixes_ftrapv=no
1232 if test "$have_clang" = "yes"; then
1233   saved_CFLAGS="$CFLAGS"
1234   CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1235   AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1236   AC_LINK_IFELSE([
1237       AC_LANG_SOURCE([[
1238           #include <stdint.h>
1239           #include <stdlib.h>
1240           int main(int argc, char **argv)
1241           {
1242             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1243                         * (int64_t)atoi(argv[3]);
1244             return x == 9;
1245           } ]])],
1246           [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1247           [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1248   if test "$ftrapv_can_link" = "no"; then
1249     AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1250     AC_LINK_IFELSE([
1251       AC_LANG_SOURCE([[
1252           #include <stdint.h>
1253           #include <stdlib.h>
1254           int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1255              *overflow=0;
1256              return a;
1257           }
1258           int main(int argc, char **argv)
1259           {
1260             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1261                         * (int64_t)atoi(argv[3]);
1262             return x == 9;
1263           } ]])],
1264           [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1265           [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1266   fi
1267   CFLAGS="$saved_CFLAGS"
1268 fi
1269
1270 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1271
1272 dnl These cflags add bunches of branches, and we haven't been able to
1273 dnl persuade ourselves that they're suitable for code that needs to be
1274 dnl constant time.
1275 AC_SUBST(CFLAGS_BUGTRAP)
1276 dnl These cflags are variant ones sutable for code that needs to be
1277 dnl constant-time.
1278 AC_SUBST(CFLAGS_CONSTTIME)
1279
1280 if test "x$enable_linker_hardening" != "xno"; then
1281     TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1282 fi
1283
1284 # For backtrace support
1285 TOR_CHECK_LDFLAGS(-rdynamic)
1286
1287 dnl ------------------------------------------------------
1288 dnl Now see if we have a -fomit-frame-pointer compiler option.
1289
1290 saved_CFLAGS="$CFLAGS"
1291 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1292 F_OMIT_FRAME_POINTER=''
1293 if test "$saved_CFLAGS" != "$CFLAGS"; then
1294   if test "$fragile_hardening" = "yes"; then
1295     F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1296   fi
1297 fi
1298 CFLAGS="$saved_CFLAGS"
1299 AC_SUBST(F_OMIT_FRAME_POINTER)
1300
1301 dnl ------------------------------------------------------
1302 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1303 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1304 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1305 dnl code will work.
1306 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1307
1308 dnl ============================================================
1309 dnl Check for libseccomp
1310
1311 if test "x$enable_seccomp" != "xno"; then
1312   AC_CHECK_HEADERS([seccomp.h])
1313   AC_SEARCH_LIBS(seccomp_init, [seccomp])
1314 fi
1315
1316 dnl ============================================================
1317 dnl Check for libscrypt
1318
1319 if test "x$enable_libscrypt" != "xno"; then
1320   AC_CHECK_HEADERS([libscrypt.h])
1321   AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1322   AC_CHECK_FUNCS([libscrypt_scrypt])
1323 fi
1324
1325 dnl ============================================================
1326 dnl We need an implementation of curve25519.
1327
1328 dnl set these defaults.
1329 build_curve25519_donna=no
1330 build_curve25519_donna_c64=no
1331 use_curve25519_donna=no
1332 use_curve25519_nacl=no
1333 CURVE25519_LIBS=
1334
1335 dnl The best choice is using curve25519-donna-c64, but that requires
1336 dnl that we
1337 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1338   tor_cv_can_use_curve25519_donna_c64,
1339   [AC_RUN_IFELSE(
1340     [AC_LANG_PROGRAM([dnl
1341       #include <stdint.h>
1342       typedef unsigned uint128_t __attribute__((mode(TI)));
1343   int func(uint64_t a, uint64_t b) {
1344            uint128_t c = ((uint128_t)a) * b;
1345            int ok = ((uint64_t)(c>>96)) == 522859 &&
1346              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1347                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1348                  (((uint64_t)(c))&0xffffffffL) == 0;
1349            return ok;
1350       }
1351   ], [dnl
1352     int ok = func( ((uint64_t)2000000000) * 1000000000,
1353                    ((uint64_t)1234567890) << 24);
1354         return !ok;
1355       ])],
1356   [tor_cv_can_use_curve25519_donna_c64=yes],
1357       [tor_cv_can_use_curve25519_donna_c64=no],
1358   [AC_LINK_IFELSE(
1359         [AC_LANG_PROGRAM([dnl
1360       #include <stdint.h>
1361       typedef unsigned uint128_t __attribute__((mode(TI)));
1362   int func(uint64_t a, uint64_t b) {
1363            uint128_t c = ((uint128_t)a) * b;
1364            int ok = ((uint64_t)(c>>96)) == 522859 &&
1365              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1366                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1367                  (((uint64_t)(c))&0xffffffffL) == 0;
1368            return ok;
1369       }
1370   ], [dnl
1371     int ok = func( ((uint64_t)2000000000) * 1000000000,
1372                  ((uint64_t)1234567890) << 24);
1373         return !ok;
1374       ])],
1375           [tor_cv_can_use_curve25519_donna_c64=cross],
1376       [tor_cv_can_use_curve25519_donna_c64=no])])])
1377
1378 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1379                   nacl/crypto_scalarmult_curve25519.h])
1380
1381 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1382   tor_cv_can_use_curve25519_nacl,
1383   [tor_saved_LIBS="$LIBS"
1384    LIBS="$LIBS -lnacl"
1385    AC_LINK_IFELSE(
1386      [AC_LANG_PROGRAM([dnl
1387        #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1388        #include <crypto_scalarmult_curve25519.h>
1389    #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1390    #include <nacl/crypto_scalarmult_curve25519.h>
1391    #endif
1392        #ifdef crypto_scalarmult_curve25519_ref_BYTES
1393    #error Hey, this is the reference implementation! That's not fast.
1394    #endif
1395      ], [
1396    unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1397      ])], [tor_cv_can_use_curve25519_nacl=yes],
1398      [tor_cv_can_use_curve25519_nacl=no])
1399    LIBS="$tor_saved_LIBS" ])
1400
1401  dnl Okay, now we need to figure out which one to actually use. Fall back
1402  dnl to curve25519-donna.c
1403
1404  if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1405    build_curve25519_donna_c64=yes
1406    use_curve25519_donna=yes
1407  elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1408    use_curve25519_nacl=yes
1409    CURVE25519_LIBS=-lnacl
1410  else
1411    build_curve25519_donna=yes
1412    use_curve25519_donna=yes
1413  fi
1414
1415 if test "x$use_curve25519_donna" = "xyes"; then
1416   AC_DEFINE(USE_CURVE25519_DONNA, 1,
1417             [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1418 fi
1419 if test "x$use_curve25519_nacl" = "xyes"; then
1420   AC_DEFINE(USE_CURVE25519_NACL, 1,
1421             [Defined if we should use a curve25519 from nacl])
1422 fi
1423 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1424   test "x$build_curve25519_donna" = "xyes")
1425 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1426   test "x$build_curve25519_donna_c64" = "xyes")
1427 AC_SUBST(CURVE25519_LIBS)
1428
1429 dnl Make sure to enable support for large off_t if available.
1430 AC_SYS_LARGEFILE
1431
1432 AC_CHECK_HEADERS([errno.h \
1433                   fcntl.h \
1434                   signal.h \
1435                   string.h \
1436                   sys/capability.h \
1437                   sys/fcntl.h \
1438                   sys/stat.h \
1439                   sys/time.h \
1440                   sys/types.h \
1441                   time.h \
1442                   unistd.h \
1443                   arpa/inet.h \
1444                   crt_externs.h \
1445                   execinfo.h \
1446                   gnu/libc-version.h \
1447                   grp.h \
1448                   ifaddrs.h \
1449                   inttypes.h \
1450                   limits.h \
1451                   linux/types.h \
1452                   machine/limits.h \
1453                   malloc.h \
1454                   malloc/malloc.h \
1455                   malloc_np.h \
1456                   netdb.h \
1457                   netinet/in.h \
1458                   netinet/in6.h \
1459                   pwd.h \
1460                   readpassphrase.h \
1461                   stdatomic.h \
1462                   sys/eventfd.h \
1463                   sys/file.h \
1464                   sys/ioctl.h \
1465                   sys/limits.h \
1466                   sys/mman.h \
1467                   sys/param.h \
1468                   sys/prctl.h \
1469                   sys/random.h \
1470                   sys/resource.h \
1471                   sys/select.h \
1472                   sys/socket.h \
1473                   sys/statvfs.h \
1474                   sys/syscall.h \
1475                   sys/sysctl.h \
1476                   sys/syslimits.h \
1477                   sys/time.h \
1478                   sys/types.h \
1479                   sys/un.h \
1480                   sys/utime.h \
1481                   sys/wait.h \
1482                   syslog.h \
1483                   utime.h])
1484
1485 AC_CHECK_HEADERS(sys/param.h)
1486
1487 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1488 [#ifdef HAVE_SYS_TYPES_H
1489 #include <sys/types.h>
1490 #endif
1491 #ifdef HAVE_SYS_SOCKET_H
1492 #include <sys/socket.h>
1493 #endif])
1494 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1495 [#ifdef HAVE_SYS_TYPES_H
1496 #include <sys/types.h>
1497 #endif
1498 #ifdef HAVE_SYS_SOCKET_H
1499 #include <sys/socket.h>
1500 #endif
1501 #ifdef HAVE_NET_IF_H
1502 #include <net/if.h>
1503 #endif
1504 #ifdef HAVE_NETINET_IN_H
1505 #include <netinet/in.h>
1506 #endif])
1507
1508 AC_CHECK_HEADERS(linux/if.h,[],[],
1509 [
1510 #ifdef HAVE_SYS_SOCKET_H
1511 #include <sys/socket.h>
1512 #endif
1513 ])
1514
1515 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1516         linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1517 [#ifdef HAVE_SYS_TYPES_H
1518 #include <sys/types.h>
1519 #endif
1520 #ifdef HAVE_SYS_SOCKET_H
1521 #include <sys/socket.h>
1522 #endif
1523 #ifdef HAVE_LIMITS_H
1524 #include <limits.h>
1525 #endif
1526 #ifdef HAVE_LINUX_TYPES_H
1527 #include <linux/types.h>
1528 #endif
1529 #ifdef HAVE_NETINET_IN6_H
1530 #include <netinet/in6.h>
1531 #endif
1532 #ifdef HAVE_NETINET_IN_H
1533 #include <netinet/in.h>
1534 #endif])
1535
1536 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1537         linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1538 [#ifdef HAVE_SYS_TYPES_H
1539 #include <sys/types.h>
1540 #endif
1541 #ifdef HAVE_SYS_SOCKET_H
1542 #include <sys/socket.h>
1543 #endif
1544 #ifdef HAVE_LIMITS_H
1545 #include <limits.h>
1546 #endif
1547 #ifdef HAVE_LINUX_TYPES_H
1548 #include <linux/types.h>
1549 #endif
1550 #ifdef HAVE_NETINET_IN6_H
1551 #include <netinet/in6.h>
1552 #endif
1553 #ifdef HAVE_NETINET_IN_H
1554 #include <netinet/in.h>
1555 #endif
1556 #ifdef HAVE_LINUX_IF_H
1557 #include <linux/if.h>
1558 #endif])
1559
1560 transparent_ok=0
1561 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1562   transparent_ok=1
1563 fi
1564 if test "x$linux_netfilter_ipv4" = "x1"; then
1565   transparent_ok=1
1566 fi
1567 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1568   transparent_ok=1
1569 fi
1570 if test "x$transparent_ok" = "x1"; then
1571   AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1572 else
1573   AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1574 fi
1575
1576 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1577 [#ifdef HAVE_SYS_TYPES_H
1578 #include <sys/types.h>
1579 #endif
1580 #ifdef HAVE_SYS_TIME_H
1581 #include <sys/time.h>
1582 #endif])
1583
1584 AC_CHECK_SIZEOF(char)
1585 AC_CHECK_SIZEOF(short)
1586 AC_CHECK_SIZEOF(int)
1587 AC_CHECK_SIZEOF(long)
1588 AC_CHECK_SIZEOF(long long)
1589 AC_CHECK_SIZEOF(__int64)
1590 AC_CHECK_SIZEOF(void *)
1591 AC_CHECK_SIZEOF(time_t)
1592 AC_CHECK_SIZEOF(size_t)
1593 AC_CHECK_SIZEOF(pid_t)
1594
1595 AC_CHECK_TYPES([uint, u_char, ssize_t])
1596
1597 AC_PC_FROM_UCONTEXT([:])
1598
1599 dnl used to include sockaddr_storage, but everybody has that.
1600 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1601 [#ifdef HAVE_SYS_TYPES_H
1602 #include <sys/types.h>
1603 #endif
1604 #ifdef HAVE_NETINET_IN_H
1605 #include <netinet/in.h>
1606 #endif
1607 #ifdef HAVE_NETINET_IN6_H
1608 #include <netinet/in6.h>
1609 #endif
1610 #ifdef HAVE_SYS_SOCKET_H
1611 #include <sys/socket.h>
1612 #endif
1613 #ifdef _WIN32
1614 #define _WIN32_WINNT 0x0501
1615 #define WIN32_LEAN_AND_MEAN
1616 #include <winsock2.h>
1617 #include <ws2tcpip.h>
1618 #endif
1619 ])
1620 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1621 [#ifdef HAVE_SYS_TYPES_H
1622 #include <sys/types.h>
1623 #endif
1624 #ifdef HAVE_NETINET_IN_H
1625 #include <netinet/in.h>
1626 #endif
1627 #ifdef HAVE_NETINET_IN6_H
1628 #include <netinet/in6.h>
1629 #endif
1630 #ifdef HAVE_SYS_SOCKET_H
1631 #include <sys/socket.h>
1632 #endif
1633 #ifdef _WIN32
1634 #define _WIN32_WINNT 0x0501
1635 #define WIN32_LEAN_AND_MEAN
1636 #include <winsock2.h>
1637 #include <ws2tcpip.h>
1638 #endif
1639 ])
1640
1641 AC_CHECK_TYPES([rlim_t], , ,
1642 [#ifdef HAVE_SYS_TYPES_H
1643 #include <sys/types.h>
1644 #endif
1645 #ifdef HAVE_SYS_TIME_H
1646 #include <sys/time.h>
1647 #endif
1648 #ifdef HAVE_SYS_RESOURCE_H
1649 #include <sys/resource.h>
1650 #endif
1651 ])
1652
1653 AX_CHECK_SIGN([time_t],
1654        [ : ],
1655        [ : ], [
1656 #ifdef HAVE_SYS_TYPES_H
1657 #include <sys/types.h>
1658 #endif
1659 #ifdef HAVE_SYS_TIME_H
1660 #include <sys/time.h>
1661 #endif
1662 #ifdef HAVE_TIME_H
1663 #include <time.h>
1664 #endif
1665 ])
1666
1667 if test "$ax_cv_decl_time_t_signed" = "no"; then
1668   AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1669 fi
1670
1671 AX_CHECK_SIGN([size_t],
1672        [ tor_cv_size_t_signed=yes ],
1673        [ tor_cv_size_t_signed=no ], [
1674 #ifdef HAVE_SYS_TYPES_H
1675 #include <sys/types.h>
1676 #endif
1677 ])
1678
1679 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1680   AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1681 fi
1682
1683 AX_CHECK_SIGN([enum always],
1684        [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1685        [ : ], [
1686  enum always { AAA, BBB, CCC };
1687 ])
1688
1689 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1690 #ifdef HAVE_SYS_SOCKET_H
1691 #include <sys/socket.h>
1692 #endif
1693 ])
1694
1695 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1696
1697 AC_CHECK_SIZEOF(cell_t)
1698
1699 # Let's see if stdatomic works. (There are some debian clangs that screw it
1700 # up; see Tor bug #26779 and debian bug 903709.)
1701 AC_CACHE_CHECK([whether C11 stdatomic.h actually works],
1702                tor_cv_stdatomic_works,
1703 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1704 #include <stdatomic.h>
1705 struct x { atomic_size_t y; };
1706 void try_atomic_init(struct x *xx)
1707 {
1708   atomic_init(&xx->y, 99);
1709   atomic_fetch_add(&xx->y, 1);
1710 }
1711 ]])], [tor_cv_stdatomic_works=yes], [tor_cv_stdatomic_works=no])])
1712
1713 if test "$tor_cv_stdatomic_works" = "yes"; then
1714    AC_DEFINE(STDATOMIC_WORKS, 1, [Set to 1 if we can compile a simple stdatomic example.])
1715 elif test "$ac_cv_header_stdatomic_h" = "yes"; then
1716    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 ])
1717 fi
1718
1719 # Now make sure that NULL can be represented as zero bytes.
1720 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1721 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1722 [[#include <stdlib.h>
1723 #include <string.h>
1724 #include <stdio.h>
1725 #ifdef HAVE_STDDEF_H
1726 #include <stddef.h>
1727 #endif
1728 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1729 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1730        [tor_cv_null_is_zero=yes],
1731        [tor_cv_null_is_zero=no],
1732        [tor_cv_null_is_zero=cross])])
1733
1734 if test "$tor_cv_null_is_zero" = "cross"; then
1735   # Cross-compiling; let's hope that the target isn't raving mad.
1736   AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1737 fi
1738
1739 if test "$tor_cv_null_is_zero" != "no"; then
1740   AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1741             [Define to 1 iff memset(0) sets pointers to NULL])
1742 fi
1743
1744 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1745 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1746 [[#include <stdlib.h>
1747 #include <string.h>
1748 #include <stdio.h>
1749 #ifdef HAVE_STDDEF_H
1750 #include <stddef.h>
1751 #endif
1752 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1753 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1754        [tor_cv_dbl0_is_zero=yes],
1755        [tor_cv_dbl0_is_zero=no],
1756        [tor_cv_dbl0_is_zero=cross])])
1757
1758 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1759   # Cross-compiling; let's hope that the target isn't raving mad.
1760   AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1761 fi
1762
1763 if test "$tor_cv_dbl0_is_zero" != "no"; then
1764   AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1765             [Define to 1 iff memset(0) sets doubles to 0.0])
1766 fi
1767
1768 # And what happens when we malloc zero?
1769 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1770 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1771 [[#include <stdlib.h>
1772 #include <string.h>
1773 #include <stdio.h>
1774 #ifdef HAVE_STDDEF_H
1775 #include <stddef.h>
1776 #endif
1777 int main () { return malloc(0)?0:1; }]])],
1778        [tor_cv_malloc_zero_works=yes],
1779        [tor_cv_malloc_zero_works=no],
1780        [tor_cv_malloc_zero_works=cross])])
1781
1782 if test "$tor_cv_malloc_zero_works" = "cross"; then
1783   # Cross-compiling; let's hope that the target isn't raving mad.
1784   AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1785 fi
1786
1787 if test "$tor_cv_malloc_zero_works" = "yes"; then
1788   AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1789             [Define to 1 iff malloc(0) returns a pointer])
1790 fi
1791
1792 # whether we seem to be in a 2s-complement world.
1793 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1794 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1795 [[int main () { int problem = ((-99) != (~99)+1);
1796 return problem ? 1 : 0; }]])],
1797        [tor_cv_twos_complement=yes],
1798        [tor_cv_twos_complement=no],
1799        [tor_cv_twos_complement=cross])])
1800
1801 if test "$tor_cv_twos_complement" = "cross"; then
1802   # Cross-compiling; let's hope that the target isn't raving mad.
1803   AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1804 fi
1805
1806 if test "$tor_cv_twos_complement" != "no"; then
1807   AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1808             [Define to 1 iff we represent negative integers with
1809              two's complement])
1810 fi
1811
1812 # What does shifting a negative value do?
1813 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1814 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1815 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1816        [tor_cv_sign_extend=yes],
1817        [tor_cv_sign_extend=no],
1818        [tor_cv_sign_extend=cross])])
1819
1820 if test "$tor_cv_sign_extend" = "cross"; then
1821   # Cross-compiling; let's hope that the target isn't raving mad.
1822   AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1823 fi
1824
1825 if test "$tor_cv_sign_extend" != "no"; then
1826   AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1827             [Define to 1 iff right-shifting a negative value performs sign-extension])
1828 fi
1829
1830 # Is uint8_t the same type as unsigned char?
1831 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1832 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1833 #include <stdint.h>
1834 extern uint8_t c;
1835 unsigned char c;]])],
1836        [tor_cv_uint8_uchar=yes],
1837        [tor_cv_uint8_uchar=no],
1838        [tor_cv_uint8_uchar=cross])])
1839
1840 if test "$tor_cv_uint8_uchar" = "cross"; then
1841   AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1842 fi
1843
1844 if test "$tor_cv_uint8_uchar" = "no"; then
1845   AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1846 fi
1847
1848 AC_ARG_WITH(tcmalloc,
1849 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library. Deprecated; see --with-malloc]),
1850 [ tcmalloc=yes ], [ tcmalloc=no ])
1851
1852 default_malloc=system
1853
1854 if test "x$enable_openbsd_malloc" = "xyes" ; then
1855   AC_MSG_NOTICE([The --enable-openbsd-malloc argument is deprecated; use --with-malloc=openbsd instead.])
1856   default_malloc=openbsd
1857 fi
1858
1859 if test "x$tcmalloc" = "xyes"; then
1860   AC_MSG_NOTICE([The --with-tcmalloc argument is deprecated; use --with-malloc=tcmalloc instead.])
1861   default_malloc=tcmalloc
1862 fi
1863
1864 AC_ARG_WITH(malloc,
1865    AS_HELP_STRING([--with-malloc=[system,jemalloc,tcmalloc,openbsd]],
1866                   [select special malloc implementation [system]]),
1867    [ malloc="$with_malloc" ], [ malloc="$default_malloc" ])
1868
1869 AS_CASE([$malloc],
1870   [tcmalloc], [
1871       PKG_CHECK_MODULES([TCMALLOC],
1872                         [libtcmalloc],
1873                         have_tcmalloc=yes,
1874                         have_tcmalloc=no)
1875
1876       if test "x$have_tcmalloc" = "xno" ; then
1877           AC_MSG_ERROR([Unable to find tcmalloc requested by --with-malloc.])
1878       fi
1879
1880       CFLAGS="$CFLAGS $TCMALLOC_CFLAGS"
1881       LIBS="$TCMALLOC_LIBS $LIBS"
1882   ],
1883
1884   [jemalloc], [
1885       PKG_CHECK_MODULES([JEMALLOC],
1886                         [jemalloc],
1887                         have_jemalloc=yes,
1888                         have_jemalloc=no)
1889
1890       if test "x$have_tcmalloc" = "xno" ; then
1891           AC_MSG_ERROR([Unable to find jemalloc requested by --with-malloc.])
1892       fi
1893
1894       CFLAGS="$CFLAGS $JEMALLOC_CFLAGS"
1895       LIBS="$JEMALLOC_LIBS $LIBS"
1896       using_custom_malloc=yes
1897   ],
1898
1899   [openbsd], [
1900     AC_MSG_WARN([The openbsd malloc port is deprecated in Tor 0.3.5 and will be removed in a future version.])
1901     enable_openbsd_malloc=yes
1902   ],
1903
1904   [system], [
1905      # handle this later, including the jemalloc fallback
1906     AC_CHECK_FUNCS(mallinfo)
1907   ],
1908
1909   [AC_MSG_ERROR([--with-malloc=`$with_malloc' not supported, see --help])
1910 ])
1911
1912 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
1913
1914 if test "$malloc" != "system"; then
1915   # Tell the C compiler not to use the system allocator functions.
1916   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1917 fi
1918 if test "$using_custom_malloc" = "yes"; then
1919   # Tell the C compiler not to use the system allocator functions.
1920   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1921 fi
1922
1923 # By default, we're going to assume we don't have mlockall()
1924 # bionic and other platforms have various broken mlockall subsystems.
1925 # Some systems don't have a working mlockall, some aren't linkable,
1926 # and some have it but don't declare it.
1927 AC_CHECK_FUNCS(mlockall)
1928 AC_CHECK_DECLS([mlockall], , , [
1929 #ifdef HAVE_SYS_MMAN_H
1930 #include <sys/mman.h>
1931 #endif])
1932
1933 # Allow user to specify an alternate syslog facility
1934 AC_ARG_WITH(syslog-facility,
1935 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1936 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1937 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1938 AC_SUBST(LOGFACILITY)
1939
1940 # Check if we have getresuid and getresgid
1941 AC_CHECK_FUNCS(getresuid getresgid)
1942
1943 # Check for gethostbyname_r in all its glorious incompatible versions.
1944 #   (This logic is based on that in Python's configure.in)
1945 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1946   [Define this if you have any gethostbyname_r()])
1947
1948 AC_CHECK_FUNC(gethostbyname_r, [
1949   AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1950   OLD_CFLAGS=$CFLAGS
1951   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1952   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1953 #include <netdb.h>
1954   ]], [[
1955     char *cp1, *cp2;
1956     struct hostent *h1, *h2;
1957     int i1, i2;
1958     (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1959   ]])],[
1960     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1961     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1962      [Define this if gethostbyname_r takes 6 arguments])
1963     AC_MSG_RESULT(6)
1964   ], [
1965     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1966 #include <netdb.h>
1967     ]], [[
1968       char *cp1, *cp2;
1969       struct hostent *h1;
1970       int i1, i2;
1971       (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1972     ]])], [
1973       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1974       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1975         [Define this if gethostbyname_r takes 5 arguments])
1976       AC_MSG_RESULT(5)
1977    ], [
1978       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1979 #include <netdb.h>
1980      ]], [[
1981        char *cp1;
1982        struct hostent *h1;
1983        struct hostent_data hd;
1984        (void) gethostbyname_r(cp1,h1,&hd);
1985      ]])], [
1986        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1987        AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1988          [Define this if gethostbyname_r takes 3 arguments])
1989        AC_MSG_RESULT(3)
1990      ], [
1991        AC_MSG_RESULT(0)
1992      ])
1993   ])
1994  ])
1995  CFLAGS=$OLD_CFLAGS
1996 ])
1997
1998 AC_CACHE_CHECK([whether the C compiler supports __func__],
1999   tor_cv_have_func_macro,
2000   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2001 #include <stdio.h>
2002 int main(int c, char **v) { puts(__func__); }])],
2003   tor_cv_have_func_macro=yes,
2004   tor_cv_have_func_macro=no))
2005
2006 AC_CACHE_CHECK([whether the C compiler supports __FUNC__],
2007   tor_cv_have_FUNC_macro,
2008   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2009 #include <stdio.h>
2010 int main(int c, char **v) { puts(__FUNC__); }])],
2011   tor_cv_have_FUNC_macro=yes,
2012   tor_cv_have_FUNC_macro=no))
2013
2014 AC_CACHE_CHECK([whether the C compiler supports __FUNCTION__],
2015   tor_cv_have_FUNCTION_macro,
2016   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2017 #include <stdio.h>
2018 int main(int c, char **v) { puts(__FUNCTION__); }])],
2019   tor_cv_have_FUNCTION_macro=yes,
2020   tor_cv_have_FUNCTION_macro=no))
2021
2022 AC_CACHE_CHECK([whether we have extern char **environ already declared],
2023   tor_cv_have_environ_declared,
2024   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2025 #ifdef HAVE_UNISTD_H
2026 #include <unistd.h>
2027 #endif
2028 #include <stdlib.h>
2029 int main(int c, char **v) { char **t = environ; }])],
2030   tor_cv_have_environ_declared=yes,
2031   tor_cv_have_environ_declared=no))
2032
2033 if test "$tor_cv_have_func_macro" = "yes"; then
2034   AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
2035 fi
2036
2037 if test "$tor_cv_have_FUNC_macro" = "yes"; then
2038   AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
2039 fi
2040
2041 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
2042   AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
2043            [Defined if the compiler supports __FUNCTION__])
2044 fi
2045
2046 if test "$tor_cv_have_environ_declared" = "yes"; then
2047   AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
2048            [Defined if we have extern char **environ already declared])
2049 fi
2050
2051 # $prefix stores the value of the --prefix command line option, or
2052 # NONE if the option wasn't set.  In the case that it wasn't set, make
2053 # it be the default, so that we can use it to expand directories now.
2054 if test "x$prefix" = "xNONE"; then
2055   prefix=$ac_default_prefix
2056 fi
2057
2058 # and similarly for $exec_prefix
2059 if test "x$exec_prefix" = "xNONE"; then
2060   exec_prefix=$prefix
2061 fi
2062
2063 if test "x$BUILDDIR" = "x"; then
2064   BUILDDIR=`pwd`
2065 fi
2066 AC_SUBST(BUILDDIR)
2067 AH_TEMPLATE([BUILDDIR],[tor's build directory])
2068 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
2069
2070 if test "x$SRCDIR" = "x"; then
2071   SRCDIR=$(cd "$srcdir"; pwd)
2072 fi
2073 AH_TEMPLATE([SRCDIR],[tor's sourcedir directory])
2074 AC_DEFINE_UNQUOTED(SRCDIR,"$SRCDIR")
2075
2076 if test "x$CONFDIR" = "x"; then
2077   CONFDIR=`eval echo $sysconfdir/tor`
2078 fi
2079 AC_SUBST(CONFDIR)
2080 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
2081 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
2082
2083 BINDIR=`eval echo $bindir`
2084 AC_SUBST(BINDIR)
2085 LOCALSTATEDIR=`eval echo $localstatedir`
2086 AC_SUBST(LOCALSTATEDIR)
2087
2088 if test "$bwin32" = "true"; then
2089   # Test if the linker supports the --nxcompat and --dynamicbase options
2090   # for Windows
2091   save_LDFLAGS="$LDFLAGS"
2092   LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
2093   AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
2094   AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
2095     [AC_MSG_RESULT([yes])]
2096     [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
2097     [AC_MSG_RESULT([no])]
2098   )
2099   LDFLAGS="$save_LDFLAGS"
2100 fi
2101
2102 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
2103 # than autoconf's macros like.
2104 if test "$GCC" = "yes"; then
2105   # Disable GCC's strict aliasing checks.  They are an hours-to-debug
2106   # accident waiting to happen.
2107   CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
2108 else
2109   # Override optimization level for non-gcc compilers
2110   CFLAGS="$CFLAGS -O"
2111   enable_gcc_warnings=no
2112   enable_gcc_warnings_advisory=no
2113 fi
2114
2115 # Warnings implies advisory-warnings and -Werror.
2116 if test "$enable_gcc_warnings" = "yes"; then
2117   enable_gcc_warnings_advisory=yes
2118   enable_fatal_warnings=yes
2119 fi
2120
2121 # OS X Lion started deprecating the system openssl. Let's just disable
2122 # all deprecation warnings on OS X. Also, to potentially make the binary
2123 # a little smaller, let's enable dead_strip.
2124 case "$host_os" in
2125
2126  darwin*)
2127     CFLAGS="$CFLAGS -Wno-deprecated-declarations"
2128     LDFLAGS="$LDFLAGS -dead_strip" ;;
2129 esac
2130
2131 # Add some more warnings which we use in development but not in the
2132 # released versions.  (Some relevant gcc versions can't handle these.)
2133 #
2134 # Note that we have to do this near the end  of the autoconf process, or
2135 # else we may run into problems when these warnings hit on the testing C
2136 # programs that autoconf wants to build.
2137 if test "x$enable_gcc_warnings_advisory" != "xno"; then
2138
2139   case "$host" in
2140     *-*-openbsd* | *-*-bitrig*)
2141       # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
2142       # That's fine, except that the headers don't pass -Wredundant-decls.
2143       # Therefore, let's disable -Wsystem-headers when we're building
2144       # with maximal warnings on OpenBSD.
2145       CFLAGS="$CFLAGS -Wno-system-headers" ;;
2146   esac
2147
2148   # GCC4.3 users once report trouble with -Wstrict-overflow=5.  GCC5 users
2149   # have it work better.
2150   # CFLAGS="$CFLAGS -Wstrict-overflow=1"
2151
2152   # This warning was added in gcc 4.3, but it appears to generate
2153   # spurious warnings in gcc 4.4.  I don't know if it works in 4.5.
2154   #CFLAGS="$CFLAGS -Wlogical-op"
2155
2156   m4_foreach_w([warning_flag], [
2157      -Waddress
2158      -Waddress-of-array-temporary
2159      -Waddress-of-temporary
2160      -Wambiguous-macro
2161      -Wanonymous-pack-parens
2162      -Warc
2163      -Warc-abi
2164      -Warc-bridge-casts-disallowed-in-nonarc
2165      -Warc-maybe-repeated-use-of-weak
2166      -Warc-performSelector-leaks
2167      -Warc-repeated-use-of-weak
2168      -Warray-bounds
2169      -Warray-bounds-pointer-arithmetic
2170      -Wasm
2171      -Wasm-operand-widths
2172      -Watomic-properties
2173      -Watomic-property-with-user-defined-accessor
2174      -Wauto-import
2175      -Wauto-storage-class
2176      -Wauto-var-id
2177      -Wavailability
2178      -Wbackslash-newline-escape
2179      -Wbad-array-new-length
2180      -Wbind-to-temporary-copy
2181      -Wbitfield-constant-conversion
2182      -Wbool-conversion
2183      -Wbool-conversions
2184      -Wbuiltin-requires-header
2185      -Wchar-align
2186      -Wcompare-distinct-pointer-types
2187      -Wcomplex-component-init
2188      -Wconditional-type-mismatch
2189      -Wconfig-macros
2190      -Wconstant-conversion
2191      -Wconstant-logical-operand
2192      -Wconstexpr-not-const
2193      -Wcustom-atomic-properties
2194      -Wdangling-field
2195      -Wdangling-initializer-list
2196      -Wdate-time
2197      -Wdelegating-ctor-cycles
2198      -Wdeprecated-implementations
2199      -Wdeprecated-register
2200      -Wdirect-ivar-access
2201      -Wdiscard-qual
2202      -Wdistributed-object-modifiers
2203      -Wdivision-by-zero
2204      -Wdollar-in-identifier-extension
2205      -Wdouble-promotion
2206      -Wduplicate-decl-specifier
2207      -Wduplicate-enum
2208      -Wduplicate-method-arg
2209      -Wduplicate-method-match
2210      -Wduplicated-cond
2211      -Wdynamic-class-memaccess
2212      -Wembedded-directive
2213      -Wempty-translation-unit
2214      -Wenum-conversion
2215      -Wexit-time-destructors
2216      -Wexplicit-ownership-type
2217      -Wextern-initializer
2218      -Wextra
2219      -Wextra-semi
2220      -Wextra-tokens
2221      -Wflexible-array-extensions
2222      -Wfloat-conversion
2223      -Wformat-non-iso
2224      -Wfour-char-constants
2225      -Wgcc-compat
2226      -Wglobal-constructors
2227      -Wgnu-array-member-paren-init
2228      -Wgnu-designator
2229      -Wgnu-static-float-init
2230      -Wheader-guard
2231      -Wheader-hygiene
2232      -Widiomatic-parentheses
2233      -Wignored-attributes
2234      -Wimplicit-atomic-properties
2235      -Wimplicit-conversion-floating-point-to-bool
2236      -Wimplicit-exception-spec-mismatch
2237      -Wimplicit-fallthrough
2238      -Wimplicit-fallthrough-per-function
2239      -Wimplicit-retain-self
2240      -Wimport-preprocessor-directive-pedantic
2241      -Wincompatible-library-redeclaration
2242      -Wincompatible-pointer-types-discards-qualifiers
2243      -Wincomplete-implementation
2244      -Wincomplete-module
2245      -Wincomplete-umbrella
2246      -Winit-self
2247      -Wint-conversions
2248      -Wint-to-void-pointer-cast
2249      -Winteger-overflow
2250      -Winvalid-constexpr
2251      -Winvalid-iboutlet
2252      -Winvalid-noreturn
2253      -Winvalid-pp-token
2254      -Winvalid-source-encoding
2255      -Winvalid-token-paste
2256      -Wknr-promoted-parameter
2257      -Wlarge-by-value-copy
2258      -Wliteral-conversion
2259      -Wliteral-range
2260      -Wlocal-type-template-args
2261      -Wlogical-op
2262      -Wloop-analysis
2263      -Wmain-return-type
2264      -Wmalformed-warning-check
2265      -Wmethod-signatures
2266      -Wmicrosoft
2267      -Wmicrosoft-exists
2268      -Wmismatched-parameter-types
2269      -Wmismatched-return-types
2270      -Wmissing-field-initializers
2271      -Wmissing-format-attribute
2272      -Wmissing-noreturn
2273      -Wmissing-selector-name
2274      -Wmissing-sysroot
2275      -Wmissing-variable-declarations
2276      -Wmodule-conflict
2277      -Wnested-anon-types
2278      -Wnewline-eof
2279      -Wnon-literal-null-conversion
2280      -Wnon-pod-varargs
2281      -Wnonportable-cfstrings
2282      -Wnormalized=nfkc
2283      -Wnull-arithmetic
2284      -Wnull-character
2285      -Wnull-conversion
2286      -Wnull-dereference
2287      -Wout-of-line-declaration
2288      -Wover-aligned
2289      -Woverlength-strings
2290      -Woverride-init
2291      -Woverriding-method-mismatch
2292      -Wpointer-type-mismatch
2293      -Wpredefined-identifier-outside-function
2294      -Wprotocol-property-synthesis-ambiguity
2295      -Wreadonly-iboutlet-property
2296      -Wreadonly-setter-attrs
2297      -Wreceiver-expr
2298      -Wreceiver-forward-class
2299      -Wreceiver-is-weak
2300      -Wreinterpret-base-class
2301      -Wrequires-super-attribute
2302      -Wreserved-user-defined-literal
2303      -Wreturn-stack-address
2304      -Wsection
2305      -Wselector-type-mismatch
2306      -Wsentinel
2307      -Wserialized-diagnostics
2308      -Wshadow
2309      -Wshift-count-negative
2310      -Wshift-count-overflow
2311      -Wshift-negative-value
2312      -Wshift-overflow=2
2313      -Wshift-sign-overflow
2314      -Wshorten-64-to-32
2315      -Wsizeof-array-argument
2316      -Wsource-uses-openmp
2317      -Wstatic-float-init
2318      -Wstatic-in-inline
2319      -Wstatic-local-in-inline
2320      -Wstrict-overflow=1
2321      -Wstring-compare
2322      -Wstring-conversion
2323      -Wstrlcpy-strlcat-size
2324      -Wstrncat-size
2325      -Wsuggest-attribute=format
2326      -Wsuggest-attribute=noreturn
2327      -Wsuper-class-method-mismatch
2328      -Wswitch-bool
2329      -Wsync-nand
2330      -Wtautological-constant-out-of-range-compare
2331      -Wtentative-definition-incomplete-type
2332      -Wtrampolines
2333      -Wtype-safety
2334      -Wtypedef-redefinition
2335      -Wtypename-missing
2336      -Wundefined-inline
2337      -Wundefined-internal
2338      -Wundefined-reinterpret-cast
2339      -Wunicode
2340      -Wunicode-whitespace
2341      -Wunknown-warning-option
2342      -Wunnamed-type-template-args
2343      -Wunneeded-member-function
2344      -Wunsequenced
2345      -Wunsupported-visibility
2346      -Wunused-but-set-parameter
2347      -Wunused-but-set-variable
2348      -Wunused-command-line-argument
2349      -Wunused-const-variable=2
2350      -Wunused-exception-parameter
2351      -Wunused-local-typedefs
2352      -Wunused-member-function
2353      -Wunused-sanitize-argument
2354      -Wunused-volatile-lvalue
2355      -Wuser-defined-literals
2356      -Wvariadic-macros
2357      -Wvector-conversion
2358      -Wvector-conversions
2359      -Wvexing-parse
2360      -Wvisibility
2361      -Wvla-extension
2362      -Wzero-length-array
2363   ], [ TOR_CHECK_CFLAGS([warning_flag]) ])
2364
2365 dnl    We should re-enable this in some later version.  Clang doesn't
2366 dnl    mind, but it causes trouble with GCC.
2367 dnl     -Wstrict-overflow=2
2368
2369 dnl    These seem to require annotations that we don't currently use,
2370 dnl    and they give false positives in our pthreads wrappers. (Clang 4)
2371 dnl     -Wthread-safety
2372 dnl     -Wthread-safety-analysis
2373 dnl     -Wthread-safety-attributes
2374 dnl     -Wthread-safety-beta
2375 dnl     -Wthread-safety-precise
2376
2377   CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2378   CFLAGS="$CFLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2379   CFLAGS="$CFLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2380   CFLAGS="$CFLAGS -Wwrite-strings"
2381   CFLAGS="$CFLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2382   CFLAGS="$CFLAGS -Waggregate-return -Wpacked -Wunused"
2383   CFLAGS="$CFLAGS -Wunused-parameter "
2384   # These interfere with building main() { return 0; }, which autoconf
2385   # likes to use as its default program.
2386   CFLAGS="$CFLAGS -Wold-style-definition -Wmissing-declarations"
2387
2388   if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2389     AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2390   fi
2391   if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2392     AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2393   fi
2394   if test "$tor_cv_cflags__warn_unused_const_variable_2" = "yes"; then
2395     AC_DEFINE([HAVE_CFLAG_WUNUSED_CONST_VARIABLE], 1, [True if we have -Wunused-const-variable])
2396   fi
2397
2398   if test "x$enable_fatal_warnings" = "xyes"; then
2399     # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2400     # default autoconf programs are full of errors.
2401     CFLAGS="$CFLAGS -Werror"
2402   fi
2403
2404 fi
2405
2406 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2407    case "$host_os" in
2408     darwin*)
2409       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.])
2410    esac
2411 fi
2412
2413 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2414
2415 AC_CONFIG_FILES([
2416         Doxyfile
2417         Makefile
2418         config.rust
2419         link_rust.sh
2420         contrib/dist/suse/tor.sh
2421         contrib/operator-tools/tor.logrotate
2422         contrib/dist/tor.sh
2423         contrib/dist/torctl
2424         contrib/dist/tor.service
2425         src/config/torrc.sample
2426         src/config/torrc.minimal
2427         src/rust/.cargo/config
2428         scripts/maint/checkOptionDocs.pl
2429         scripts/maint/updateVersions.pl
2430 ])
2431
2432 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2433   regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2434   for file in $regular_mans ; do
2435     if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2436       echo "==================================";
2437       echo;
2438       echo "Building Tor has failed since manpages cannot be built.";
2439       echo;
2440       echo "You need asciidoc installed to be able to build the manpages.";
2441       echo "To build without manpages, use the --disable-asciidoc argument";
2442       echo "when calling configure.";
2443       echo;
2444       echo "==================================";
2445       exit 1;
2446     fi
2447   done
2448 fi
2449
2450 if test "$fragile_hardening" = "yes"; then
2451   AC_MSG_WARN([
2452
2453 ============
2454 Warning!  Building Tor with --enable-fragile-hardening (also known as
2455 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2456 other kinds of attacks easier. A Tor instance build with this option will be
2457 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2458 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2459 denial of service attacks. For more information, see
2460 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening
2461 ============
2462   ])
2463 fi
2464
2465 AC_OUTPUT