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.4.0.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 For now both MSVC and MinGW rust libraries will output static libs with
 507   dnl the MSVC naming convention.
 508   if test "$bwin32" = "true"; then
 509     tor_rust_static_name=tor_rust.lib
 510   else
 511     tor_rust_static_name=libtor_rust.a
 512   fi
 513
 514   AC_CANONICAL_BUILD
 515
 516   if test -n "$TOR_RUST_TARGET"; then
 517     if test "$host" = "$build"; then
 518       AC_MSG_ERROR([HOST = BUILD is invalid if TOR_RUST_TARGET is specified, see configure --help for more information.])
 519     fi
 520     RUST_TARGET_PROP="target = '$TOR_RUST_TARGET'"
 521     TOR_RUST_LIB_PATH="src/rust/target/$TOR_RUST_TARGET/release/$tor_rust_static_name"
 522   else
 523     if test "$host" != "$build"; then
 524       AC_MSG_ERROR([TOR_RUST_TARGET must be specified when cross-compiling with Rust enabled.])
 525     fi
 526     RUST_TARGET_PROP=
 527     TOR_RUST_LIB_PATH="src/rust/target/release/$tor_rust_static_name"
 528   fi
 529
 530   AC_SUBST(RUST_TARGET_PROP)
 531   AC_SUBST(TOR_RUST_LIB_PATH)
 532   AC_SUBST(CARGO_ONLINE)
 533   AC_SUBST(RUST_WARN)
 534   AC_SUBST(RUST_DL)
 535
 536   dnl Let's check the rustc version, too
 537   AC_MSG_CHECKING([rust version])
 538   RUSTC_VERSION=`$RUSTC --version`
 539   RUSTC_VERSION_MAJOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 1`
 540   RUSTC_VERSION_MINOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 2`
 541   if test "x$RUSTC_VERSION_MAJOR" = "x" -o "x$RUSTC_VERSION_MINOR" = "x"; then
 542     AC_MSG_ERROR([rustc version couldn't be identified])
 543   fi
 544   if test "$RUSTC_VERSION_MAJOR" -lt 2 -a "$RUSTC_VERSION_MINOR" -lt 14; then
 545     AC_MSG_ERROR([rustc must be at least version 1.14])
 546   fi
 547   AC_MSG_RESULT([$RUSTC_VERSION])
 548 fi
 549
 550 AC_SEARCH_LIBS(socket, [socket network])
 551 AC_SEARCH_LIBS(gethostbyname, [nsl])
 552 AC_SEARCH_LIBS(dlopen, [dl])
 553 AC_SEARCH_LIBS(inet_aton, [resolv])
 554 AC_SEARCH_LIBS(backtrace, [execinfo])
 555 saved_LIBS="$LIBS"
 556 AC_SEARCH_LIBS([clock_gettime], [rt])
 557 if test "$LIBS" != "$saved_LIBS"; then
 558    # Looks like we need -lrt for clock_gettime().
 559    have_rt=yes
 560 fi
 561
 562 if test "$bwin32" = "false"; then
 563   AC_SEARCH_LIBS(pthread_create, [pthread])
 564   AC_SEARCH_LIBS(pthread_detach, [pthread])
 565 fi
 566
 567 AM_CONDITIONAL(THREADS_WIN32, test "$bwin32" = "true")
 568 AM_CONDITIONAL(THREADS_PTHREADS, test "$bwin32" = "false")
 569
 570 AC_CHECK_FUNCS(
 571         _NSGetEnviron \
 572         RtlSecureZeroMemory \
 573         SecureZeroMemory \
 574         accept4 \
 575         backtrace \
 576         backtrace_symbols_fd \
 577         eventfd \
 578         explicit_bzero \
 579         timingsafe_memcmp \
 580         flock \
 581         ftime \
 582         get_current_dir_name \
 583         getaddrinfo \
 584         getdelim \
 585         getifaddrs \
 586         getline \
 587         getpass \
 588         getrlimit \
 589         gettimeofday \
 590         gmtime_r \
 591         gnu_get_libc_version \
 592         htonll \
 593         inet_aton \
 594         ioctl \
 595         issetugid \
 596         llround \
 597         localtime_r \
 598         lround \
 599         memmem \
 600         memset_s \
 601         mmap \
 602         pipe \
 603         pipe2 \
 604         prctl \
 605         readpassphrase \
 606         rint \
 607         sigaction \
 608         socketpair \
 609         statvfs \
 610         strncasecmp \
 611         strcasecmp \
 612         strlcat \
 613         strlcpy \
 614         strnlen \
 615         strptime \
 616         strtok_r \
 617         strtoull \
 618         sysconf \
 619         sysctl \
 620         truncate \
 621         uname \
 622         usleep \
 623         vasprintf \
 624         _vscprintf
 625 )
 626
 627 # Apple messed up when they added some functions: they
 628 # forgot to decorate them with appropriate AVAILABLE_MAC_OS_VERSION
 629 # checks.
 630
 631 # We should only probe for these functions if we are sure that we
 632 # are not targeting OS X 10.9 or earlier.
 633 AC_MSG_CHECKING([for a pre-Yosemite OS X build target])
 634 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 635 #ifdef __APPLE__
 636 #  include <AvailabilityMacros.h>
 637 #  ifndef MAC_OS_X_VERSION_10_10
 638 #    define MAC_OS_X_VERSION_10_10 101000
 639 #  endif
 640 #  if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
 641 #    if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_10
 642 #      error "Running on Mac OS X 10.9 or earlier"
 643 #    endif
 644 #  endif
 645 #endif
 646 ]], [[]])],
 647    [on_macos_pre_10_10=no ; AC_MSG_RESULT([no])],
 648    [on_macos_pre_10_10=yes; AC_MSG_RESULT([yes])])
 649
 650 if test "$on_macos_pre_10_10" = "no"; then
 651   AC_CHECK_FUNCS(
 652         mach_approximate_time \
 653   )
 654 fi
 655
 656 # We should only probe for these functions if we are sure that we
 657 # are not targeting OSX 10.11 or earlier.
 658 AC_MSG_CHECKING([for a pre-Sierra OSX build target])
 659 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 660 #ifdef __APPLE__
 661 #  include <AvailabilityMacros.h>
 662 #  ifndef MAC_OS_X_VERSION_10_12
 663 #    define MAC_OS_X_VERSION_10_12 101200
 664 #  endif
 665 #  if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
 666 #    if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
 667 #      error "Running on Mac OSX 10.11 or earlier"
 668 #    endif
 669 #  endif
 670 #endif
 671 ]], [[]])],
 672    [on_macos_pre_10_12=no ; AC_MSG_RESULT([no])],
 673    [on_macos_pre_10_12=yes; AC_MSG_RESULT([yes])])
 674
 675 if test "$on_macos_pre_10_12" = "no"; then
 676   AC_CHECK_FUNCS(
 677         clock_gettime \
 678         getentropy \
 679   )
 680 fi
 681
 682 if test "$bwin32" != "true"; then
 683   AC_CHECK_HEADERS(pthread.h)
 684   AC_CHECK_FUNCS(pthread_create)
 685   AC_CHECK_FUNCS(pthread_condattr_setclock)
 686 fi
 687
 688 if test "$bwin32" = "true"; then
 689   AC_CHECK_DECLS([SecureZeroMemory, _getwch], , , [
 690 #include <windows.h>
 691 #include <conio.h>
 692 #include <wchar.h>
 693                  ])
 694 fi
 695
 696 AM_CONDITIONAL(BUILD_READPASSPHRASE_C,
 697   test "x$ac_cv_func_readpassphrase" = "xno" && test "$bwin32" = "false")
 698
 699 AC_MSG_CHECKING([whether free(NULL) works])
 700 AC_RUN_IFELSE([AC_LANG_PROGRAM([
 701   #include <stdlib.h>
 702 ], [
 703 char *p = NULL;
 704 free(p);
 705 ])],
 706 [free_null_ok=true; AC_MSG_RESULT(yes)],
 707 [free_null_ok=false; AC_MSG_RESULT(no)],
 708 [free_null_ok=cross; AC_MSG_RESULT(cross)])
 709
 710 if test "$free_null_ok" = "false"; then
 711    AC_MSG_ERROR([Your libc implementation doesn't allow free(NULL), as required by C99.])
 712 fi
 713
 714 dnl ------------------------------------------------------
 715 dnl Where do you live, libevent?  And how do we call you?
 716
 717 if test "$bwin32" = "true"; then
 718   TOR_LIB_WS32=-lws2_32
 719   TOR_LIB_IPHLPAPI=-liphlpapi
 720   # Some of the cargo-cults recommend -lwsock32 as well, but I don't
 721   # think it's actually necessary.
 722   TOR_LIB_GDI=-lgdi32
 723   TOR_LIB_USERENV=-luserenv
 724 else
 725   TOR_LIB_WS32=
 726   TOR_LIB_GDI=
 727   TOR_LIB_USERENV=
 728 fi
 729 AC_SUBST(TOR_LIB_WS32)
 730 AC_SUBST(TOR_LIB_GDI)
 731 AC_SUBST(TOR_LIB_IPHLPAPI)
 732 AC_SUBST(TOR_LIB_USERENV)
 733
 734 tor_libevent_pkg_redhat="libevent"
 735 tor_libevent_pkg_debian="libevent-dev"
 736 tor_libevent_devpkg_redhat="libevent-devel"
 737 tor_libevent_devpkg_debian="libevent-dev"
 738
 739 dnl On Gnu/Linux or any place we require it, we'll add librt to the Libevent
 740 dnl linking for static builds.
 741 STATIC_LIBEVENT_FLAGS=""
 742 if test "$enable_static_libevent" = "yes"; then
 743     if test "$have_rt" = "yes"; then
 744       STATIC_LIBEVENT_FLAGS=" -lrt "
 745     fi
 746 fi
 747
 748 TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32], [
 749 #ifdef _WIN32
 750 #include <winsock2.h>
 751 #endif
 752 #include <sys/time.h>
 753 #include <sys/types.h>
 754 #include <event2/event.h>], [
 755 #ifdef _WIN32
 756 #include <winsock2.h>
 757 #endif
 758 struct event_base;
 759 struct event_base *event_base_new(void);
 760 void event_base_free(struct event_base *);],
 761     [
 762 #ifdef _WIN32
 763 {WSADATA d; WSAStartup(0x101,&d); }
 764 #endif
 765 event_base_free(event_base_new());
 766 ], [--with-libevent-dir], [/opt/libevent])
 767
 768 dnl Determine the incantation needed to link libevent.
 769 save_LIBS="$LIBS"
 770 save_LDFLAGS="$LDFLAGS"
 771 save_CPPFLAGS="$CPPFLAGS"
 772
 773 LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
 774 LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
 775 CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
 776
 777 AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
 778
 779 if test "$enable_static_libevent" = "yes"; then
 780    if test "$tor_cv_library_libevent_dir" = "(system)"; then
 781      AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
 782    else
 783      TOR_LIBEVENT_LIBS="$TOR_LIBDIR_libevent/libevent.a $STATIC_LIBEVENT_FLAGS"
 784    fi
 785 else
 786      if test "x$ac_cv_header_event2_event_h" = "xyes"; then
 787        AC_SEARCH_LIBS(event_new, [event event_core], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for event_new"))
 788        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"))
 789
 790        if test "$ac_cv_search_event_new" != "none required"; then
 791          TOR_LIBEVENT_LIBS="$ac_cv_search_event_new"
 792        fi
 793        if test "$ac_cv_search_evdns_base_new" != "none required"; then
 794          TOR_LIBEVENT_LIBS="$ac_cv_search_evdns_base_new $TOR_LIBEVENT_LIBS"
 795        fi
 796      else
 797        AC_MSG_ERROR("libevent2 is required but the headers could not be found")
 798      fi
 799 fi
 800
 801 dnl Now check for particular libevent functions.
 802 AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file \
 803                 evutil_secure_rng_add_bytes \
 804                 evdns_base_get_nameserver_addr \
 805
 806 ])
 807
 808 LIBS="$save_LIBS"
 809 LDFLAGS="$save_LDFLAGS"
 810 CPPFLAGS="$save_CPPFLAGS"
 811
 812 dnl Check that libevent is at least at version 2.0.10, the first stable
 813 dnl release of its series
 814 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
 815 AC_MSG_CHECKING([whether Libevent is new enough])
 816 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 817 #include <event2/event.h>
 818 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
 819 #error
 820 int x = y(zz);
 821 #else
 822 int x = 1;
 823 #endif
 824 ])], [ AC_MSG_RESULT([yes]) ],
 825    [ AC_MSG_RESULT([no])
 826      AC_MSG_ERROR([Libevent is not new enough.  We require 2.0.10-stable or later]) ] )
 827
 828 LIBS="$save_LIBS"
 829 LDFLAGS="$save_LDFLAGS"
 830 CPPFLAGS="$save_CPPFLAGS"
 831
 832 AC_SUBST(TOR_LIBEVENT_LIBS)
 833
 834 dnl ------------------------------------------------------
 835 dnl Where do you live, libm?
 836
 837 dnl On some platforms (Haiku/BeOS) the math library is
 838 dnl part of libroot. In which case don't link against lm
 839 TOR_LIB_MATH=""
 840 save_LIBS="$LIBS"
 841 AC_SEARCH_LIBS(pow, [m], , AC_MSG_ERROR([Could not find pow in libm or libc.]))
 842 if test "$ac_cv_search_pow" != "none required"; then
 843     TOR_LIB_MATH="$ac_cv_search_pow"
 844 fi
 845 LIBS="$save_LIBS"
 846 AC_SUBST(TOR_LIB_MATH)
 847
 848 dnl ------------------------------------------------------
 849 dnl Hello, NSS.  You're new around here.
 850 if test "x$enable_nss" = "xyes"; then
 851   PKG_CHECK_MODULES(NSS,
 852      [nss],
 853      [have_nss=yes],
 854      [have_nss=no; AC_MSG_ERROR([You asked for NSS but I can't find it.])])
 855   AC_SUBST(NSS_CFLAGS)
 856   AC_SUBST(NSS_LIBS)
 857 fi
 858
 859 dnl ------------------------------------------------------
 860 dnl Where do you live, openssl?  And how do we call you?
 861
 862 if test "x$enable_nss" != "xyes"; then
 863
 864 tor_openssl_pkg_redhat="openssl"
 865 tor_openssl_pkg_debian="libssl-dev"
 866 tor_openssl_devpkg_redhat="openssl-devel"
 867 tor_openssl_devpkg_debian="libssl-dev"
 868
 869 ALT_openssl_WITHVAL=""
 870 AC_ARG_WITH(ssl-dir,
 871   AS_HELP_STRING(--with-ssl-dir=PATH, [obsolete alias for --with-openssl-dir]),
 872   [
 873       if test "x$withval" != "xno" && test "x$withval" != "x"; then
 874          ALT_openssl_WITHVAL="$withval"
 875       fi
 876   ])
 877
 878 AC_MSG_NOTICE([Now, we'll look for OpenSSL >= 1.0.1])
 879 TOR_SEARCH_LIBRARY(openssl, $tryssldir, [-lssl -lcrypto $TOR_LIB_GDI $TOR_LIB_WS32],
 880     [#include <openssl/ssl.h>
 881      char *getenv(const char *);],
 882     [struct ssl_cipher_st;
 883      unsigned SSL_CIPHER_get_id(const struct ssl_cipher_st *);
 884      char *getenv(const char *);],
 885     dnl This funny-looking test program calls getenv, so that the compiler
 886     dnl will neither make code that call SSL_CIPHER_get_id(NULL) [producing
 887     dnl a crash], nor optimize out the call to SSL_CIPHER_get_id().
 888     dnl We look for SSL_cipher_get_id() because it is present in
 889     dnl OpenSSL >=1.0.1, because it is not deprecated, and because Tor
 890     dnl depends on it.
 891     [if (getenv("THIS_SHOULDNT_BE_SET_X201803")) SSL_CIPHER_get_id((void *)0);], [],
 892     [/usr/local/opt/openssl /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /opt/openssl])
 893
 894 dnl XXXX check for OPENSSL_VERSION_NUMBER == SSLeay()
 895
 896 if test "$enable_static_openssl" = "yes"; then
 897    if test "$tor_cv_library_openssl_dir" = "(system)"; then
 898      AC_MSG_ERROR("You must specify an explicit --with-openssl-dir=x option when using --enable-static-openssl")
 899    else
 900      TOR_OPENSSL_LIBS="$TOR_LIBDIR_openssl/libssl.a $TOR_LIBDIR_openssl/libcrypto.a"
 901    fi
 902 else
 903      TOR_OPENSSL_LIBS="-lssl -lcrypto"
 904 fi
 905 AC_SUBST(TOR_OPENSSL_LIBS)
 906
 907 dnl Now check for particular openssl functions.
 908 save_LIBS="$LIBS"
 909 save_LDFLAGS="$LDFLAGS"
 910 save_CPPFLAGS="$CPPFLAGS"
 911 LIBS="$TOR_OPENSSL_LIBS $LIBS"
 912 LDFLAGS="$TOR_LDFLAGS_openssl $LDFLAGS"
 913 CPPFLAGS="$TOR_CPPFLAGS_openssl $CPPFLAGS"
 914
 915 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 916 #include <openssl/opensslv.h>
 917 #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x1000100fL
 918 #error "too old"
 919 #endif
 920    ]], [[]])],
 921    [ : ],
 922    [ 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.]) ])
 923
 924 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 925 #include <openssl/opensslv.h>
 926 #include <openssl/evp.h>
 927 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_ECDSA)
 928 #error "no ECC"
 929 #endif
 930 #if !defined(NID_X9_62_prime256v1) || !defined(NID_secp224r1)
 931 #error "curves unavailable"
 932 #endif
 933    ]], [[]])],
 934    [ : ],
 935    [ 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.]) ])
 936
 937 AC_CHECK_MEMBERS([struct ssl_method_st.get_cipher_by_char], , ,
 938 [#include <openssl/ssl.h>
 939 ])
 940
 941 AC_CHECK_FUNCS([ \
 942                 ERR_load_KDF_strings \
 943                 SSL_SESSION_get_master_key \
 944                 SSL_get_server_random \
 945                 SSL_get_client_ciphers \
 946                 SSL_get_client_random \
 947                 SSL_CTX_set1_groups_list \
 948                 SSL_CIPHER_find \
 949                 SSL_CTX_set_security_level \
 950                 TLS_method
 951                ])
 952
 953 dnl Check if OpenSSL has scrypt implementation.
 954 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
 955
 956 dnl Check if OpenSSL structures are opaque
 957 AC_CHECK_MEMBERS([SSL.state], , ,
 958 [#include <openssl/ssl.h>
 959 ])
 960
 961 AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT()
 962 #include <openssl/sha.h>
 963 ])
 964
 965 fi # enable_nss
 966
 967 dnl ======================================================================
 968 dnl Can we use KIST?
 969
 970 dnl Define the set of checks for KIST scheduler support.
 971 AC_DEFUN([CHECK_KIST_SUPPORT],[
 972   dnl KIST needs struct tcp_info and for certain members to exist.
 973   AC_CHECK_MEMBERS(
 974     [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
 975     , ,[[#include <netinet/tcp.h>]])
 976   dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
 977   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
 978                      #include <linux/sockios.h>
 979                      #ifndef SIOCOUTQNSD
 980                      #error
 981                      #endif
 982                      ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
 983   if test "x$have_siocoutqnsd" = "xyes"; then
 984     if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
 985       if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
 986         have_kist_support=yes
 987       fi
 988     fi
 989   fi
 990 ])
 991 dnl Now, trigger the check.
 992 CHECK_KIST_SUPPORT
 993 AS_IF([test "x$have_kist_support" = "xyes"],
 994       [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
 995                                         on this system])],
 996       [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
 997
 998 LIBS="$save_LIBS"
 999 LDFLAGS="$save_LDFLAGS"
1000 CPPFLAGS="$save_CPPFLAGS"
1001
1002 dnl ------------------------------------------------------
1003 dnl Where do you live, zlib?  And how do we call you?
1004
1005 tor_zlib_pkg_redhat="zlib"
1006 tor_zlib_pkg_debian="zlib1g"
1007 tor_zlib_devpkg_redhat="zlib-devel"
1008 tor_zlib_devpkg_debian="zlib1g-dev"
1009
1010 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
1011     [#include <zlib.h>],
1012     [const char * zlibVersion(void);],
1013     [zlibVersion();], [--with-zlib-dir],
1014     [/opt/zlib])
1015
1016 if test "$enable_static_zlib" = "yes"; then
1017    if test "$tor_cv_library_zlib_dir" = "(system)"; then
1018      AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
1019  using --enable-static-zlib")
1020    else
1021      TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
1022    fi
1023 else
1024      TOR_ZLIB_LIBS="-lz"
1025 fi
1026 AC_SUBST(TOR_ZLIB_LIBS)
1027
1028 dnl ------------------------------------------------------
1029 dnl Where we do we find lzma?
1030
1031 AC_ARG_ENABLE(lzma,
1032       AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
1033       [case "${enableval}" in
1034         "yes") lzma=true ;;
1035         "no")  lzma=false ;;
1036         * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
1037       esac], [lzma=auto])
1038
1039 if test "x$enable_lzma" = "xno"; then
1040     have_lzma=no;
1041 else
1042     PKG_CHECK_MODULES([LZMA],
1043                       [liblzma],
1044                       have_lzma=yes,
1045                       have_lzma=no)
1046
1047     if test "x$have_lzma" = "xno" ; then
1048         AC_MSG_WARN([Unable to find liblzma.])
1049     fi
1050 fi
1051
1052 if test "x$have_lzma" = "xyes"; then
1053     AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
1054     TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
1055     TOR_LZMA_LIBS="${LZMA_LIBS}"
1056 fi
1057 AC_SUBST(TOR_LZMA_CFLAGS)
1058 AC_SUBST(TOR_LZMA_LIBS)
1059
1060 dnl ------------------------------------------------------
1061 dnl Where we do we find zstd?
1062
1063 AC_ARG_ENABLE(zstd,
1064       AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
1065       [case "${enableval}" in
1066         "yes") zstd=true ;;
1067         "no")  zstd=false ;;
1068         * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
1069       esac], [zstd=auto])
1070
1071 if test "x$enable_zstd" = "xno"; then
1072     have_zstd=no;
1073 else
1074     PKG_CHECK_MODULES([ZSTD],
1075                       [libzstd >= 1.1],
1076                       have_zstd=yes,
1077                       have_zstd=no)
1078
1079     if test "x$have_zstd" = "xno" ; then
1080         AC_MSG_WARN([Unable to find libzstd.])
1081     fi
1082 fi
1083
1084 if test "x$have_zstd" = "xyes"; then
1085     AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
1086     TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
1087     TOR_ZSTD_LIBS="${ZSTD_LIBS}"
1088
1089     dnl now check for zstd functions
1090     save_LIBS="$LIBS"
1091     save_CFLAGS="$CFLAGS"
1092     LIBS="$LIBS $ZSTD_LIBS"
1093     CFLAGS="$CFLAGS $ZSTD_CFLAGS"
1094     AC_CHECK_FUNCS(ZSTD_estimateCStreamSize \
1095                    ZSTD_estimateDCtxSize)
1096     LIBS="$save_LIBS"
1097     CFLAGS="$save_CFLAGS"
1098 fi
1099 AC_SUBST(TOR_ZSTD_CFLAGS)
1100 AC_SUBST(TOR_ZSTD_LIBS)
1101
1102 dnl ----------------------------------------------------------------------
1103 dnl Check if libcap is available for capabilities.
1104
1105 tor_cap_pkg_debian="libcap2"
1106 tor_cap_pkg_redhat="libcap"
1107 tor_cap_devpkg_debian="libcap-dev"
1108 tor_cap_devpkg_redhat="libcap-devel"
1109
1110 AC_CHECK_LIB([cap], [cap_init], [],
1111   AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
1112 )
1113 AC_CHECK_FUNCS(cap_set_proc)
1114
1115 dnl ---------------------------------------------------------------------
1116 dnl Now that we know about our major libraries, we can check for compiler
1117 dnl and linker hardening options.  We need to do this with the libraries known,
1118 dnl since sometimes the linker will like an option but not be willing to
1119 dnl use it with a build of a library.
1120
1121 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
1122 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"
1123
1124 CFLAGS_FTRAPV=
1125 CFLAGS_FWRAPV=
1126 CFLAGS_ASAN=
1127 CFLAGS_UBSAN=
1128
1129
1130 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1131 #if !defined(__clang__)
1132 #error
1133 #endif])], have_clang=yes, have_clang=no)
1134
1135 if test "x$enable_pic" = "xyes"; then
1136     TOR_CHECK_CFLAGS(-fPIC)
1137 fi
1138
1139 if test "x$enable_gcc_hardening" != "xno"; then
1140     CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
1141     if test "x$have_clang" = "xyes"; then
1142         TOR_CHECK_CFLAGS(-Qunused-arguments)
1143     fi
1144     TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
1145     AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
1146     AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1147 m4_ifdef([AS_VAR_IF],[
1148     AS_VAR_IF(can_compile, [yes],
1149         AS_VAR_IF(can_link, [yes],
1150                   [],
1151                   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.)]))
1152         )])
1153     AS_VAR_POPDEF([can_link])
1154     AS_VAR_POPDEF([can_compile])
1155     TOR_CHECK_CFLAGS(-Wstack-protector)
1156     TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1157     if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1158        if test "$enable_pic" != "yes"; then
1159            # If we have already enabled -fPIC, then we don't also need to
1160            # compile with -fPIE...
1161            TOR_CHECK_CFLAGS(-fPIE)
1162        fi
1163        # ... but we want to link our executables with -pie in any case, since
1164        # they're executables, not a library.
1165        TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1166     fi
1167     TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1168 fi
1169
1170 if test "$fragile_hardening" = "yes"; then
1171     TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1172    if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1173       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.])
1174    fi
1175
1176    if test "$tor_cv_cflags__ftrapv" != "yes"; then
1177      AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1178    fi
1179
1180    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1181     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1182       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*])
1183     fi
1184
1185    TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1186     if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1187       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*])
1188     fi
1189
1190 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1191 fi
1192
1193 dnl Find the correct libraries to add in order to use the sanitizers.
1194 dnl
1195 dnl When building Rust, Cargo will run the linker with the -nodefaultlibs
1196 dnl option, which will prevent the compiler from linking the sanitizer
1197 dnl libraries it needs.  We need to specify them manually.
1198 dnl
1199 dnl What's more, we need to specify them in a linker script rather than
1200 dnl from build.rs: these options aren't allowed in the cargo:rustc-flags
1201 dnl variable.
1202 RUST_LINKER_OPTIONS=""
1203 if test "x$have_clang" = "xyes"; then
1204         if test "x$CFLAGS_ASAN" != "x"; then
1205                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=$CFLAGS_ASAN -Cdefault-linker-libraries"
1206         fi
1207         if test "x$CFLAGS_UBSAN" != "x"; then
1208                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=$CFLAGS_UBSAN -Cdefault-linker-libraries"
1209         fi
1210 else
1211         if test "x$CFLAGS_ASAN" != "x"; then
1212                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=-fsanitize=address -Cdefault-linker-libraries"
1213         fi
1214         if test "x$CFLAGS_UBSAN" != "x"; then
1215                 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -Clink-arg=-fsanitize=undefined -Cdefault-linker-libraries"
1216         fi
1217 fi
1218 AC_SUBST(RUST_LINKER_OPTIONS)
1219
1220 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1221 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1222
1223 mulodi_fixes_ftrapv=no
1224 if test "$have_clang" = "yes"; then
1225   saved_CFLAGS="$CFLAGS"
1226   CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1227   AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1228   AC_LINK_IFELSE([
1229       AC_LANG_SOURCE([[
1230           #include <stdint.h>
1231           #include <stdlib.h>
1232           int main(int argc, char **argv)
1233           {
1234             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1235                         * (int64_t)atoi(argv[3]);
1236             return x == 9;
1237           } ]])],
1238           [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1239           [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1240   if test "$ftrapv_can_link" = "no"; then
1241     AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1242     AC_LINK_IFELSE([
1243       AC_LANG_SOURCE([[
1244           #include <stdint.h>
1245           #include <stdlib.h>
1246           int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1247              *overflow=0;
1248              return a;
1249           }
1250           int main(int argc, char **argv)
1251           {
1252             int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1253                         * (int64_t)atoi(argv[3]);
1254             return x == 9;
1255           } ]])],
1256           [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1257           [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1258   fi
1259   CFLAGS="$saved_CFLAGS"
1260 fi
1261
1262 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1263
1264 dnl These cflags add bunches of branches, and we haven't been able to
1265 dnl persuade ourselves that they're suitable for code that needs to be
1266 dnl constant time.
1267 AC_SUBST(CFLAGS_BUGTRAP)
1268 dnl These cflags are variant ones sutable for code that needs to be
1269 dnl constant-time.
1270 AC_SUBST(CFLAGS_CONSTTIME)
1271
1272 if test "x$enable_linker_hardening" != "xno"; then
1273     TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1274 fi
1275
1276 # For backtrace support
1277 TOR_CHECK_LDFLAGS(-rdynamic)
1278
1279 dnl ------------------------------------------------------
1280 dnl Now see if we have a -fomit-frame-pointer compiler option.
1281
1282 saved_CFLAGS="$CFLAGS"
1283 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1284 F_OMIT_FRAME_POINTER=''
1285 if test "$saved_CFLAGS" != "$CFLAGS"; then
1286   if test "$fragile_hardening" = "yes"; then
1287     F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1288   fi
1289 fi
1290 CFLAGS="$saved_CFLAGS"
1291 AC_SUBST(F_OMIT_FRAME_POINTER)
1292
1293 dnl ------------------------------------------------------
1294 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1295 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1296 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1297 dnl code will work.
1298 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1299
1300 dnl ============================================================
1301 dnl Check for libseccomp
1302
1303 if test "x$enable_seccomp" != "xno"; then
1304   AC_CHECK_HEADERS([seccomp.h])
1305   AC_SEARCH_LIBS(seccomp_init, [seccomp])
1306 fi
1307
1308 dnl ============================================================
1309 dnl Check for libscrypt
1310
1311 if test "x$enable_libscrypt" != "xno"; then
1312   AC_CHECK_HEADERS([libscrypt.h])
1313   AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1314   AC_CHECK_FUNCS([libscrypt_scrypt])
1315 fi
1316
1317 dnl ============================================================
1318 dnl We need an implementation of curve25519.
1319
1320 dnl set these defaults.
1321 build_curve25519_donna=no
1322 build_curve25519_donna_c64=no
1323 use_curve25519_donna=no
1324 use_curve25519_nacl=no
1325 CURVE25519_LIBS=
1326
1327 dnl The best choice is using curve25519-donna-c64, but that requires
1328 dnl that we
1329 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1330   tor_cv_can_use_curve25519_donna_c64,
1331   [AC_RUN_IFELSE(
1332     [AC_LANG_PROGRAM([dnl
1333       #include <stdint.h>
1334       typedef unsigned uint128_t __attribute__((mode(TI)));
1335   int func(uint64_t a, uint64_t b) {
1336            uint128_t c = ((uint128_t)a) * b;
1337            int ok = ((uint64_t)(c>>96)) == 522859 &&
1338              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1339                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1340                  (((uint64_t)(c))&0xffffffffL) == 0;
1341            return ok;
1342       }
1343   ], [dnl
1344     int ok = func( ((uint64_t)2000000000) * 1000000000,
1345                    ((uint64_t)1234567890) << 24);
1346         return !ok;
1347       ])],
1348   [tor_cv_can_use_curve25519_donna_c64=yes],
1349       [tor_cv_can_use_curve25519_donna_c64=no],
1350   [AC_LINK_IFELSE(
1351         [AC_LANG_PROGRAM([dnl
1352       #include <stdint.h>
1353       typedef unsigned uint128_t __attribute__((mode(TI)));
1354   int func(uint64_t a, uint64_t b) {
1355            uint128_t c = ((uint128_t)a) * b;
1356            int ok = ((uint64_t)(c>>96)) == 522859 &&
1357              (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1358                  (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1359                  (((uint64_t)(c))&0xffffffffL) == 0;
1360            return ok;
1361       }
1362   ], [dnl
1363     int ok = func( ((uint64_t)2000000000) * 1000000000,
1364                  ((uint64_t)1234567890) << 24);
1365         return !ok;
1366       ])],
1367           [tor_cv_can_use_curve25519_donna_c64=cross],
1368       [tor_cv_can_use_curve25519_donna_c64=no])])])
1369
1370 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1371                   nacl/crypto_scalarmult_curve25519.h])
1372
1373 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1374   tor_cv_can_use_curve25519_nacl,
1375   [tor_saved_LIBS="$LIBS"
1376    LIBS="$LIBS -lnacl"
1377    AC_LINK_IFELSE(
1378      [AC_LANG_PROGRAM([dnl
1379        #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1380        #include <crypto_scalarmult_curve25519.h>
1381    #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1382    #include <nacl/crypto_scalarmult_curve25519.h>
1383    #endif
1384        #ifdef crypto_scalarmult_curve25519_ref_BYTES
1385    #error Hey, this is the reference implementation! That's not fast.
1386    #endif
1387      ], [
1388    unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1389      ])], [tor_cv_can_use_curve25519_nacl=yes],
1390      [tor_cv_can_use_curve25519_nacl=no])
1391    LIBS="$tor_saved_LIBS" ])
1392
1393  dnl Okay, now we need to figure out which one to actually use. Fall back
1394  dnl to curve25519-donna.c
1395
1396  if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1397    build_curve25519_donna_c64=yes
1398    use_curve25519_donna=yes
1399  elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1400    use_curve25519_nacl=yes
1401    CURVE25519_LIBS=-lnacl
1402  else
1403    build_curve25519_donna=yes
1404    use_curve25519_donna=yes
1405  fi
1406
1407 if test "x$use_curve25519_donna" = "xyes"; then
1408   AC_DEFINE(USE_CURVE25519_DONNA, 1,
1409             [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1410 fi
1411 if test "x$use_curve25519_nacl" = "xyes"; then
1412   AC_DEFINE(USE_CURVE25519_NACL, 1,
1413             [Defined if we should use a curve25519 from nacl])
1414 fi
1415 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1416   test "x$build_curve25519_donna" = "xyes")
1417 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1418   test "x$build_curve25519_donna_c64" = "xyes")
1419 AC_SUBST(CURVE25519_LIBS)
1420
1421 dnl Make sure to enable support for large off_t if available.
1422 AC_SYS_LARGEFILE
1423
1424 AC_CHECK_HEADERS([errno.h \
1425                   fcntl.h \
1426                   signal.h \
1427                   string.h \
1428                   sys/capability.h \
1429                   sys/fcntl.h \
1430                   sys/stat.h \
1431                   sys/time.h \
1432                   sys/types.h \
1433                   time.h \
1434                   unistd.h \
1435                   arpa/inet.h \
1436                   crt_externs.h \
1437                   execinfo.h \
1438                   gnu/libc-version.h \
1439                   grp.h \
1440                   ifaddrs.h \
1441                   inttypes.h \
1442                   limits.h \
1443                   linux/types.h \
1444                   machine/limits.h \
1445                   malloc.h \
1446                   malloc/malloc.h \
1447                   malloc_np.h \
1448                   netdb.h \
1449                   netinet/in.h \
1450                   netinet/in6.h \
1451                   pwd.h \
1452                   readpassphrase.h \
1453                   stdatomic.h \
1454                   sys/eventfd.h \
1455                   sys/file.h \
1456                   sys/ioctl.h \
1457                   sys/limits.h \
1458                   sys/mman.h \
1459                   sys/param.h \
1460                   sys/prctl.h \
1461                   sys/random.h \
1462                   sys/resource.h \
1463                   sys/select.h \
1464                   sys/socket.h \
1465                   sys/statvfs.h \
1466                   sys/syscall.h \
1467                   sys/sysctl.h \
1468                   sys/syslimits.h \
1469                   sys/time.h \
1470                   sys/types.h \
1471                   sys/un.h \
1472                   sys/utime.h \
1473                   sys/wait.h \
1474                   syslog.h \
1475                   utime.h])
1476
1477 AC_CHECK_HEADERS(sys/param.h)
1478
1479 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1480 [#ifdef HAVE_SYS_TYPES_H
1481 #include <sys/types.h>
1482 #endif
1483 #ifdef HAVE_SYS_SOCKET_H
1484 #include <sys/socket.h>
1485 #endif])
1486 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1487 [#ifdef HAVE_SYS_TYPES_H
1488 #include <sys/types.h>
1489 #endif
1490 #ifdef HAVE_SYS_SOCKET_H
1491 #include <sys/socket.h>
1492 #endif
1493 #ifdef HAVE_NET_IF_H
1494 #include <net/if.h>
1495 #endif
1496 #ifdef HAVE_NETINET_IN_H
1497 #include <netinet/in.h>
1498 #endif])
1499
1500 AC_CHECK_HEADERS(linux/if.h,[],[],
1501 [
1502 #ifdef HAVE_SYS_SOCKET_H
1503 #include <sys/socket.h>
1504 #endif
1505 ])
1506
1507 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1508         linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1509 [#ifdef HAVE_SYS_TYPES_H
1510 #include <sys/types.h>
1511 #endif
1512 #ifdef HAVE_SYS_SOCKET_H
1513 #include <sys/socket.h>
1514 #endif
1515 #ifdef HAVE_LIMITS_H
1516 #include <limits.h>
1517 #endif
1518 #ifdef HAVE_LINUX_TYPES_H
1519 #include <linux/types.h>
1520 #endif
1521 #ifdef HAVE_NETINET_IN6_H
1522 #include <netinet/in6.h>
1523 #endif
1524 #ifdef HAVE_NETINET_IN_H
1525 #include <netinet/in.h>
1526 #endif])
1527
1528 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1529         linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1530 [#ifdef HAVE_SYS_TYPES_H
1531 #include <sys/types.h>
1532 #endif
1533 #ifdef HAVE_SYS_SOCKET_H
1534 #include <sys/socket.h>
1535 #endif
1536 #ifdef HAVE_LIMITS_H
1537 #include <limits.h>
1538 #endif
1539 #ifdef HAVE_LINUX_TYPES_H
1540 #include <linux/types.h>
1541 #endif
1542 #ifdef HAVE_NETINET_IN6_H
1543 #include <netinet/in6.h>
1544 #endif
1545 #ifdef HAVE_NETINET_IN_H
1546 #include <netinet/in.h>
1547 #endif
1548 #ifdef HAVE_LINUX_IF_H
1549 #include <linux/if.h>
1550 #endif])
1551
1552 transparent_ok=0
1553 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1554   transparent_ok=1
1555 fi
1556 if test "x$linux_netfilter_ipv4" = "x1"; then
1557   transparent_ok=1
1558 fi
1559 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1560   transparent_ok=1
1561 fi
1562 if test "x$transparent_ok" = "x1"; then
1563   AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1564 else
1565   AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1566 fi
1567
1568 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1569 [#ifdef HAVE_SYS_TYPES_H
1570 #include <sys/types.h>
1571 #endif
1572 #ifdef HAVE_SYS_TIME_H
1573 #include <sys/time.h>
1574 #endif])
1575
1576 AC_CHECK_SIZEOF(char)
1577 AC_CHECK_SIZEOF(short)
1578 AC_CHECK_SIZEOF(int)
1579 AC_CHECK_SIZEOF(long)
1580 AC_CHECK_SIZEOF(long long)
1581 AC_CHECK_SIZEOF(__int64)
1582 AC_CHECK_SIZEOF(void *)
1583 AC_CHECK_SIZEOF(time_t)
1584 AC_CHECK_SIZEOF(size_t)
1585 AC_CHECK_SIZEOF(pid_t)
1586
1587 AC_CHECK_TYPES([uint, u_char, ssize_t])
1588
1589 AC_PC_FROM_UCONTEXT([:])
1590
1591 dnl used to include sockaddr_storage, but everybody has that.
1592 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1593 [#ifdef HAVE_SYS_TYPES_H
1594 #include <sys/types.h>
1595 #endif
1596 #ifdef HAVE_NETINET_IN_H
1597 #include <netinet/in.h>
1598 #endif
1599 #ifdef HAVE_NETINET_IN6_H
1600 #include <netinet/in6.h>
1601 #endif
1602 #ifdef HAVE_SYS_SOCKET_H
1603 #include <sys/socket.h>
1604 #endif
1605 #ifdef _WIN32
1606 #define _WIN32_WINNT 0x0501
1607 #define WIN32_LEAN_AND_MEAN
1608 #include <winsock2.h>
1609 #include <ws2tcpip.h>
1610 #endif
1611 ])
1612 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1613 [#ifdef HAVE_SYS_TYPES_H
1614 #include <sys/types.h>
1615 #endif
1616 #ifdef HAVE_NETINET_IN_H
1617 #include <netinet/in.h>
1618 #endif
1619 #ifdef HAVE_NETINET_IN6_H
1620 #include <netinet/in6.h>
1621 #endif
1622 #ifdef HAVE_SYS_SOCKET_H
1623 #include <sys/socket.h>
1624 #endif
1625 #ifdef _WIN32
1626 #define _WIN32_WINNT 0x0501
1627 #define WIN32_LEAN_AND_MEAN
1628 #include <winsock2.h>
1629 #include <ws2tcpip.h>
1630 #endif
1631 ])
1632
1633 AC_CHECK_TYPES([rlim_t], , ,
1634 [#ifdef HAVE_SYS_TYPES_H
1635 #include <sys/types.h>
1636 #endif
1637 #ifdef HAVE_SYS_TIME_H
1638 #include <sys/time.h>
1639 #endif
1640 #ifdef HAVE_SYS_RESOURCE_H
1641 #include <sys/resource.h>
1642 #endif
1643 ])
1644
1645 AX_CHECK_SIGN([time_t],
1646        [ : ],
1647        [ : ], [
1648 #ifdef HAVE_SYS_TYPES_H
1649 #include <sys/types.h>
1650 #endif
1651 #ifdef HAVE_SYS_TIME_H
1652 #include <sys/time.h>
1653 #endif
1654 #ifdef HAVE_TIME_H
1655 #include <time.h>
1656 #endif
1657 ])
1658
1659 if test "$ax_cv_decl_time_t_signed" = "no"; then
1660   AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1661 fi
1662
1663 AX_CHECK_SIGN([size_t],
1664        [ tor_cv_size_t_signed=yes ],
1665        [ tor_cv_size_t_signed=no ], [
1666 #ifdef HAVE_SYS_TYPES_H
1667 #include <sys/types.h>
1668 #endif
1669 ])
1670
1671 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1672   AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1673 fi
1674
1675 AX_CHECK_SIGN([enum always],
1676        [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1677        [ : ], [
1678  enum always { AAA, BBB, CCC };
1679 ])
1680
1681 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1682 #ifdef HAVE_SYS_SOCKET_H
1683 #include <sys/socket.h>
1684 #endif
1685 ])
1686
1687 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1688
1689 AC_CHECK_SIZEOF(cell_t)
1690
1691 # Let's see if stdatomic works. (There are some debian clangs that screw it
1692 # up; see Tor bug #26779 and debian bug 903709.)
1693 AC_CACHE_CHECK([whether C11 stdatomic.h actually works],
1694                tor_cv_stdatomic_works,
1695 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1696 #include <stdatomic.h>
1697 struct x { atomic_size_t y; };
1698 void try_atomic_init(struct x *xx)
1699 {
1700   atomic_init(&xx->y, 99);
1701   atomic_fetch_add(&xx->y, 1);
1702 }
1703 ]])], [tor_cv_stdatomic_works=yes], [tor_cv_stdatomic_works=no])])
1704
1705 if test "$tor_cv_stdatomic_works" = "yes"; then
1706    AC_DEFINE(STDATOMIC_WORKS, 1, [Set to 1 if we can compile a simple stdatomic example.])
1707 elif test "$ac_cv_header_stdatomic_h" = "yes"; then
1708    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 ])
1709 fi
1710
1711 # Now make sure that NULL can be represented as zero bytes.
1712 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1713 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1714 [[#include <stdlib.h>
1715 #include <string.h>
1716 #include <stdio.h>
1717 #ifdef HAVE_STDDEF_H
1718 #include <stddef.h>
1719 #endif
1720 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1721 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1722        [tor_cv_null_is_zero=yes],
1723        [tor_cv_null_is_zero=no],
1724        [tor_cv_null_is_zero=cross])])
1725
1726 if test "$tor_cv_null_is_zero" = "cross"; then
1727   # Cross-compiling; let's hope that the target isn't raving mad.
1728   AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1729 fi
1730
1731 if test "$tor_cv_null_is_zero" != "no"; then
1732   AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1733             [Define to 1 iff memset(0) sets pointers to NULL])
1734 fi
1735
1736 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1737 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1738 [[#include <stdlib.h>
1739 #include <string.h>
1740 #include <stdio.h>
1741 #ifdef HAVE_STDDEF_H
1742 #include <stddef.h>
1743 #endif
1744 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1745 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1746        [tor_cv_dbl0_is_zero=yes],
1747        [tor_cv_dbl0_is_zero=no],
1748        [tor_cv_dbl0_is_zero=cross])])
1749
1750 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1751   # Cross-compiling; let's hope that the target isn't raving mad.
1752   AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1753 fi
1754
1755 if test "$tor_cv_dbl0_is_zero" != "no"; then
1756   AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1757             [Define to 1 iff memset(0) sets doubles to 0.0])
1758 fi
1759
1760 # And what happens when we malloc zero?
1761 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1762 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1763 [[#include <stdlib.h>
1764 #include <string.h>
1765 #include <stdio.h>
1766 #ifdef HAVE_STDDEF_H
1767 #include <stddef.h>
1768 #endif
1769 int main () { return malloc(0)?0:1; }]])],
1770        [tor_cv_malloc_zero_works=yes],
1771        [tor_cv_malloc_zero_works=no],
1772        [tor_cv_malloc_zero_works=cross])])
1773
1774 if test "$tor_cv_malloc_zero_works" = "cross"; then
1775   # Cross-compiling; let's hope that the target isn't raving mad.
1776   AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1777 fi
1778
1779 if test "$tor_cv_malloc_zero_works" = "yes"; then
1780   AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1781             [Define to 1 iff malloc(0) returns a pointer])
1782 fi
1783
1784 # whether we seem to be in a 2s-complement world.
1785 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1786 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1787 [[int main () { int problem = ((-99) != (~99)+1);
1788 return problem ? 1 : 0; }]])],
1789        [tor_cv_twos_complement=yes],
1790        [tor_cv_twos_complement=no],
1791        [tor_cv_twos_complement=cross])])
1792
1793 if test "$tor_cv_twos_complement" = "cross"; then
1794   # Cross-compiling; let's hope that the target isn't raving mad.
1795   AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1796 fi
1797
1798 if test "$tor_cv_twos_complement" != "no"; then
1799   AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1800             [Define to 1 iff we represent negative integers with
1801              two's complement])
1802 fi
1803
1804 # What does shifting a negative value do?
1805 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1806 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1807 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1808        [tor_cv_sign_extend=yes],
1809        [tor_cv_sign_extend=no],
1810        [tor_cv_sign_extend=cross])])
1811
1812 if test "$tor_cv_sign_extend" = "cross"; then
1813   # Cross-compiling; let's hope that the target isn't raving mad.
1814   AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1815 fi
1816
1817 if test "$tor_cv_sign_extend" != "no"; then
1818   AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1819             [Define to 1 iff right-shifting a negative value performs sign-extension])
1820 fi
1821
1822 # Is uint8_t the same type as unsigned char?
1823 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1824 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1825 #include <stdint.h>
1826 extern uint8_t c;
1827 unsigned char c;]])],
1828        [tor_cv_uint8_uchar=yes],
1829        [tor_cv_uint8_uchar=no],
1830        [tor_cv_uint8_uchar=cross])])
1831
1832 if test "$tor_cv_uint8_uchar" = "cross"; then
1833   AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1834 fi
1835
1836 if test "$tor_cv_uint8_uchar" = "no"; then
1837   AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1838 fi
1839
1840 AC_ARG_WITH(tcmalloc,
1841 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library. Deprecated; see --with-malloc]),
1842 [ tcmalloc=yes ], [ tcmalloc=no ])
1843
1844 default_malloc=system
1845
1846 if test "x$enable_openbsd_malloc" = "xyes" ; then
1847   AC_MSG_NOTICE([The --enable-openbsd-malloc argument is deprecated; use --with-malloc=openbsd instead.])
1848   default_malloc=openbsd
1849 fi
1850
1851 if test "x$tcmalloc" = "xyes"; then
1852   AC_MSG_NOTICE([The --with-tcmalloc argument is deprecated; use --with-malloc=tcmalloc instead.])
1853   default_malloc=tcmalloc
1854 fi
1855
1856 AC_ARG_WITH(malloc,
1857    AS_HELP_STRING([--with-malloc=[system,jemalloc,tcmalloc,openbsd]],
1858                   [select special malloc implementation [system]]),
1859    [ malloc="$with_malloc" ], [ malloc="$default_malloc" ])
1860
1861 AS_CASE([$malloc],
1862   [tcmalloc], [
1863       PKG_CHECK_MODULES([TCMALLOC],
1864                         [libtcmalloc],
1865                         have_tcmalloc=yes,
1866                         have_tcmalloc=no)
1867
1868       if test "x$have_tcmalloc" = "xno" ; then
1869           AC_MSG_ERROR([Unable to find tcmalloc requested by --with-malloc.])
1870       fi
1871
1872       CFLAGS="$CFLAGS $TCMALLOC_CFLAGS"
1873       LIBS="$TCMALLOC_LIBS $LIBS"
1874   ],
1875
1876   [jemalloc], [
1877       PKG_CHECK_MODULES([JEMALLOC],
1878                         [jemalloc],
1879                         have_jemalloc=yes,
1880                         have_jemalloc=no)
1881
1882       if test "x$have_tcmalloc" = "xno" ; then
1883           AC_MSG_ERROR([Unable to find jemalloc requested by --with-malloc.])
1884       fi
1885
1886       CFLAGS="$CFLAGS $JEMALLOC_CFLAGS"
1887       LIBS="$JEMALLOC_LIBS $LIBS"
1888       using_custom_malloc=yes
1889   ],
1890
1891   [openbsd], [
1892     AC_MSG_WARN([The openbsd malloc port is deprecated in Tor 0.3.5 and will be removed in a future version.])
1893     enable_openbsd_malloc=yes
1894   ],
1895
1896   [system], [
1897      # handle this later, including the jemalloc fallback
1898     AC_CHECK_FUNCS(mallinfo)
1899   ],
1900
1901   [AC_MSG_ERROR([--with-malloc=`$with_malloc' not supported, see --help])
1902 ])
1903
1904 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
1905
1906 if test "$malloc" != "system"; then
1907   # Tell the C compiler not to use the system allocator functions.
1908   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1909 fi
1910 if test "$using_custom_malloc" = "yes"; then
1911   # Tell the C compiler not to use the system allocator functions.
1912   TOR_CHECK_CFLAGS([-fno-builtin-malloc -fno-builtin-realloc -fno-builtin-calloc -fno-builtin-free])
1913 fi
1914
1915 # By default, we're going to assume we don't have mlockall()
1916 # bionic and other platforms have various broken mlockall subsystems.
1917 # Some systems don't have a working mlockall, some aren't linkable,
1918 # and some have it but don't declare it.
1919 AC_CHECK_FUNCS(mlockall)
1920 AC_CHECK_DECLS([mlockall], , , [
1921 #ifdef HAVE_SYS_MMAN_H
1922 #include <sys/mman.h>
1923 #endif])
1924
1925 # Allow user to specify an alternate syslog facility
1926 AC_ARG_WITH(syslog-facility,
1927 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1928 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1929 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1930 AC_SUBST(LOGFACILITY)
1931
1932 # Check if we have getresuid and getresgid
1933 AC_CHECK_FUNCS(getresuid getresgid)
1934
1935 # Check for gethostbyname_r in all its glorious incompatible versions.
1936 #   (This logic is based on that in Python's configure.in)
1937 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1938   [Define this if you have any gethostbyname_r()])
1939
1940 AC_CHECK_FUNC(gethostbyname_r, [
1941   AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1942   OLD_CFLAGS=$CFLAGS
1943   CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1944   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1945 #include <netdb.h>
1946   ]], [[
1947     char *cp1, *cp2;
1948     struct hostent *h1, *h2;
1949     int i1, i2;
1950     (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1951   ]])],[
1952     AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1953     AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1954      [Define this if gethostbyname_r takes 6 arguments])
1955     AC_MSG_RESULT(6)
1956   ], [
1957     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1958 #include <netdb.h>
1959     ]], [[
1960       char *cp1, *cp2;
1961       struct hostent *h1;
1962       int i1, i2;
1963       (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1964     ]])], [
1965       AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1966       AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1967         [Define this if gethostbyname_r takes 5 arguments])
1968       AC_MSG_RESULT(5)
1969    ], [
1970       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1971 #include <netdb.h>
1972      ]], [[
1973        char *cp1;
1974        struct hostent *h1;
1975        struct hostent_data hd;
1976        (void) gethostbyname_r(cp1,h1,&hd);
1977      ]])], [
1978        AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1979        AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1980          [Define this if gethostbyname_r takes 3 arguments])
1981        AC_MSG_RESULT(3)
1982      ], [
1983        AC_MSG_RESULT(0)
1984      ])
1985   ])
1986  ])
1987  CFLAGS=$OLD_CFLAGS
1988 ])
1989
1990 AC_CACHE_CHECK([whether the C compiler supports __func__],
1991   tor_cv_have_func_macro,
1992   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1993 #include <stdio.h>
1994 int main(int c, char **v) { puts(__func__); }])],
1995   tor_cv_have_func_macro=yes,
1996   tor_cv_have_func_macro=no))
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 __FUNCTION__],
2007   tor_cv_have_FUNCTION_macro,
2008   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2009 #include <stdio.h>
2010 int main(int c, char **v) { puts(__FUNCTION__); }])],
2011   tor_cv_have_FUNCTION_macro=yes,
2012   tor_cv_have_FUNCTION_macro=no))
2013
2014 AC_CACHE_CHECK([whether we have extern char **environ already declared],
2015   tor_cv_have_environ_declared,
2016   AC_COMPILE_IFELSE([AC_LANG_SOURCE([
2017 #ifdef HAVE_UNISTD_H
2018 #include <unistd.h>
2019 #endif
2020 #include <stdlib.h>
2021 int main(int c, char **v) { char **t = environ; }])],
2022   tor_cv_have_environ_declared=yes,
2023   tor_cv_have_environ_declared=no))
2024
2025 if test "$tor_cv_have_func_macro" = "yes"; then
2026   AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
2027 fi
2028
2029 if test "$tor_cv_have_FUNC_macro" = "yes"; then
2030   AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
2031 fi
2032
2033 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
2034   AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
2035            [Defined if the compiler supports __FUNCTION__])
2036 fi
2037
2038 if test "$tor_cv_have_environ_declared" = "yes"; then
2039   AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
2040            [Defined if we have extern char **environ already declared])
2041 fi
2042
2043 # $prefix stores the value of the --prefix command line option, or
2044 # NONE if the option wasn't set.  In the case that it wasn't set, make
2045 # it be the default, so that we can use it to expand directories now.
2046 if test "x$prefix" = "xNONE"; then
2047   prefix=$ac_default_prefix
2048 fi
2049
2050 # and similarly for $exec_prefix
2051 if test "x$exec_prefix" = "xNONE"; then
2052   exec_prefix=$prefix
2053 fi
2054
2055 if test "x$BUILDDIR" = "x"; then
2056   BUILDDIR=`pwd`
2057 fi
2058 AC_SUBST(BUILDDIR)
2059 AH_TEMPLATE([BUILDDIR],[tor's build directory])
2060 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
2061
2062 if test "x$SRCDIR" = "x"; then
2063   SRCDIR=$(cd "$srcdir"; pwd)
2064 fi
2065 AH_TEMPLATE([SRCDIR],[tor's sourcedir directory])
2066 AC_DEFINE_UNQUOTED(SRCDIR,"$SRCDIR")
2067
2068 if test "x$CONFDIR" = "x"; then
2069   CONFDIR=`eval echo $sysconfdir/tor`
2070 fi
2071 AC_SUBST(CONFDIR)
2072 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
2073 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
2074
2075 BINDIR=`eval echo $bindir`
2076 AC_SUBST(BINDIR)
2077 LOCALSTATEDIR=`eval echo $localstatedir`
2078 AC_SUBST(LOCALSTATEDIR)
2079
2080 if test "$bwin32" = "true"; then
2081   # Test if the linker supports the --nxcompat and --dynamicbase options
2082   # for Windows
2083   save_LDFLAGS="$LDFLAGS"
2084   LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
2085   AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
2086   AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
2087     [AC_MSG_RESULT([yes])]
2088     [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
2089     [AC_MSG_RESULT([no])]
2090   )
2091   LDFLAGS="$save_LDFLAGS"
2092 fi
2093
2094 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
2095 # than autoconf's macros like.
2096 if test "$GCC" = "yes"; then
2097   # Disable GCC's strict aliasing checks.  They are an hours-to-debug
2098   # accident waiting to happen.
2099   CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
2100 else
2101   # Override optimization level for non-gcc compilers
2102   CFLAGS="$CFLAGS -O"
2103   enable_gcc_warnings=no
2104   enable_gcc_warnings_advisory=no
2105 fi
2106
2107 # Warnings implies advisory-warnings and -Werror.
2108 if test "$enable_gcc_warnings" = "yes"; then
2109   enable_gcc_warnings_advisory=yes
2110   enable_fatal_warnings=yes
2111 fi
2112
2113 # OS X Lion started deprecating the system openssl. Let's just disable
2114 # all deprecation warnings on OS X. Also, to potentially make the binary
2115 # a little smaller, let's enable dead_strip.
2116 case "$host_os" in
2117
2118  darwin*)
2119     CFLAGS="$CFLAGS -Wno-deprecated-declarations"
2120     LDFLAGS="$LDFLAGS -dead_strip" ;;
2121 esac
2122
2123 # Add some more warnings which we use in development but not in the
2124 # released versions.  (Some relevant gcc versions can't handle these.)
2125 #
2126 # Note that we have to do this near the end  of the autoconf process, or
2127 # else we may run into problems when these warnings hit on the testing C
2128 # programs that autoconf wants to build.
2129 if test "x$enable_gcc_warnings_advisory" != "xno"; then
2130
2131   case "$host" in
2132     *-*-openbsd* | *-*-bitrig*)
2133       # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
2134       # That's fine, except that the headers don't pass -Wredundant-decls.
2135       # Therefore, let's disable -Wsystem-headers when we're building
2136       # with maximal warnings on OpenBSD.
2137       CFLAGS="$CFLAGS -Wno-system-headers" ;;
2138   esac
2139
2140   # GCC4.3 users once report trouble with -Wstrict-overflow=5.  GCC5 users
2141   # have it work better.
2142   # CFLAGS="$CFLAGS -Wstrict-overflow=1"
2143
2144   # This warning was added in gcc 4.3, but it appears to generate
2145   # spurious warnings in gcc 4.4.  I don't know if it works in 4.5.
2146   #CFLAGS="$CFLAGS -Wlogical-op"
2147
2148   m4_foreach_w([warning_flag], [
2149      -Waddress
2150      -Waddress-of-array-temporary
2151      -Waddress-of-temporary
2152      -Wambiguous-macro
2153      -Wanonymous-pack-parens
2154      -Warc
2155      -Warc-abi
2156      -Warc-bridge-casts-disallowed-in-nonarc
2157      -Warc-maybe-repeated-use-of-weak
2158      -Warc-performSelector-leaks
2159      -Warc-repeated-use-of-weak
2160      -Warray-bounds
2161      -Warray-bounds-pointer-arithmetic
2162      -Wasm
2163      -Wasm-operand-widths
2164      -Watomic-properties
2165      -Watomic-property-with-user-defined-accessor
2166      -Wauto-import
2167      -Wauto-storage-class
2168      -Wauto-var-id
2169      -Wavailability
2170      -Wbackslash-newline-escape
2171      -Wbad-array-new-length
2172      -Wbind-to-temporary-copy
2173      -Wbitfield-constant-conversion
2174      -Wbool-conversion
2175      -Wbool-conversions
2176      -Wbuiltin-requires-header
2177      -Wchar-align
2178      -Wcompare-distinct-pointer-types
2179      -Wcomplex-component-init
2180      -Wconditional-type-mismatch
2181      -Wconfig-macros
2182      -Wconstant-conversion
2183      -Wconstant-logical-operand
2184      -Wconstexpr-not-const
2185      -Wcustom-atomic-properties
2186      -Wdangling-field
2187      -Wdangling-initializer-list
2188      -Wdate-time
2189      -Wdelegating-ctor-cycles
2190      -Wdeprecated-implementations
2191      -Wdeprecated-register
2192      -Wdirect-ivar-access
2193      -Wdiscard-qual
2194      -Wdistributed-object-modifiers
2195      -Wdivision-by-zero
2196      -Wdollar-in-identifier-extension
2197      -Wdouble-promotion
2198      -Wduplicate-decl-specifier
2199      -Wduplicate-enum
2200      -Wduplicate-method-arg
2201      -Wduplicate-method-match
2202      -Wduplicated-cond
2203      -Wdynamic-class-memaccess
2204      -Wembedded-directive
2205      -Wempty-translation-unit
2206      -Wenum-conversion
2207      -Wexit-time-destructors
2208      -Wexplicit-ownership-type
2209      -Wextern-initializer
2210      -Wextra
2211      -Wextra-semi
2212      -Wextra-tokens
2213      -Wflexible-array-extensions
2214      -Wfloat-conversion
2215      -Wformat-non-iso
2216      -Wfour-char-constants
2217      -Wgcc-compat
2218      -Wglobal-constructors
2219      -Wgnu-array-member-paren-init
2220      -Wgnu-designator
2221      -Wgnu-static-float-init
2222      -Wheader-guard
2223      -Wheader-hygiene
2224      -Widiomatic-parentheses
2225      -Wignored-attributes
2226      -Wimplicit-atomic-properties
2227      -Wimplicit-conversion-floating-point-to-bool
2228      -Wimplicit-exception-spec-mismatch
2229      -Wimplicit-fallthrough
2230      -Wimplicit-fallthrough-per-function
2231      -Wimplicit-retain-self
2232      -Wimport-preprocessor-directive-pedantic
2233      -Wincompatible-library-redeclaration
2234      -Wincompatible-pointer-types-discards-qualifiers
2235      -Wincomplete-implementation
2236      -Wincomplete-module
2237      -Wincomplete-umbrella
2238      -Winit-self
2239      -Wint-conversions
2240      -Wint-to-void-pointer-cast
2241      -Winteger-overflow
2242      -Winvalid-constexpr
2243      -Winvalid-iboutlet
2244      -Winvalid-noreturn
2245      -Winvalid-pp-token
2246      -Winvalid-source-encoding
2247      -Winvalid-token-paste
2248      -Wknr-promoted-parameter
2249      -Wlarge-by-value-copy
2250      -Wliteral-conversion
2251      -Wliteral-range
2252      -Wlocal-type-template-args
2253      -Wlogical-op
2254      -Wloop-analysis
2255      -Wmain-return-type
2256      -Wmalformed-warning-check
2257      -Wmethod-signatures
2258      -Wmicrosoft
2259      -Wmicrosoft-exists
2260      -Wmismatched-parameter-types
2261      -Wmismatched-return-types
2262      -Wmissing-field-initializers
2263      -Wmissing-format-attribute
2264      -Wmissing-noreturn
2265      -Wmissing-selector-name
2266      -Wmissing-sysroot
2267      -Wmissing-variable-declarations
2268      -Wmodule-conflict
2269      -Wnested-anon-types
2270      -Wnewline-eof
2271      -Wnon-literal-null-conversion
2272      -Wnon-pod-varargs
2273      -Wnonportable-cfstrings
2274      -Wnormalized=nfkc
2275      -Wnull-arithmetic
2276      -Wnull-character
2277      -Wnull-conversion
2278      -Wnull-dereference
2279      -Wout-of-line-declaration
2280      -Wover-aligned
2281      -Woverlength-strings
2282      -Woverride-init
2283      -Woverriding-method-mismatch
2284      -Wpointer-type-mismatch
2285      -Wpredefined-identifier-outside-function
2286      -Wprotocol-property-synthesis-ambiguity
2287      -Wreadonly-iboutlet-property
2288      -Wreadonly-setter-attrs
2289      -Wreceiver-expr
2290      -Wreceiver-forward-class
2291      -Wreceiver-is-weak
2292      -Wreinterpret-base-class
2293      -Wrequires-super-attribute
2294      -Wreserved-user-defined-literal
2295      -Wreturn-stack-address
2296      -Wsection
2297      -Wselector-type-mismatch
2298      -Wsentinel
2299      -Wserialized-diagnostics
2300      -Wshadow
2301      -Wshift-count-negative
2302      -Wshift-count-overflow
2303      -Wshift-negative-value
2304      -Wshift-overflow=2
2305      -Wshift-sign-overflow
2306      -Wshorten-64-to-32
2307      -Wsizeof-array-argument
2308      -Wsource-uses-openmp
2309      -Wstatic-float-init
2310      -Wstatic-in-inline
2311      -Wstatic-local-in-inline
2312      -Wstrict-overflow=1
2313      -Wstring-compare
2314      -Wstring-conversion
2315      -Wstrlcpy-strlcat-size
2316      -Wstrncat-size
2317      -Wsuggest-attribute=format
2318      -Wsuggest-attribute=noreturn
2319      -Wsuper-class-method-mismatch
2320      -Wswitch-bool
2321      -Wsync-nand
2322      -Wtautological-constant-out-of-range-compare
2323      -Wtentative-definition-incomplete-type
2324      -Wtrampolines
2325      -Wtype-safety
2326      -Wtypedef-redefinition
2327      -Wtypename-missing
2328      -Wundefined-inline
2329      -Wundefined-internal
2330      -Wundefined-reinterpret-cast
2331      -Wunicode
2332      -Wunicode-whitespace
2333      -Wunknown-warning-option
2334      -Wunnamed-type-template-args
2335      -Wunneeded-member-function
2336      -Wunsequenced
2337      -Wunsupported-visibility
2338      -Wunused-but-set-parameter
2339      -Wunused-but-set-variable
2340      -Wunused-command-line-argument
2341      -Wunused-const-variable=2
2342      -Wunused-exception-parameter
2343      -Wunused-local-typedefs
2344      -Wunused-member-function
2345      -Wunused-sanitize-argument
2346      -Wunused-volatile-lvalue
2347      -Wuser-defined-literals
2348      -Wvariadic-macros
2349      -Wvector-conversion
2350      -Wvector-conversions
2351      -Wvexing-parse
2352      -Wvisibility
2353      -Wvla-extension
2354      -Wzero-length-array
2355   ], [ TOR_CHECK_CFLAGS([warning_flag]) ])
2356
2357 dnl    We should re-enable this in some later version.  Clang doesn't
2358 dnl    mind, but it causes trouble with GCC.
2359 dnl     -Wstrict-overflow=2
2360
2361 dnl    These seem to require annotations that we don't currently use,
2362 dnl    and they give false positives in our pthreads wrappers. (Clang 4)
2363 dnl     -Wthread-safety
2364 dnl     -Wthread-safety-analysis
2365 dnl     -Wthread-safety-attributes
2366 dnl     -Wthread-safety-beta
2367 dnl     -Wthread-safety-precise
2368
2369   CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2370   CFLAGS="$CFLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2371   CFLAGS="$CFLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2372   CFLAGS="$CFLAGS -Wwrite-strings"
2373   CFLAGS="$CFLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2374   CFLAGS="$CFLAGS -Waggregate-return -Wpacked -Wunused"
2375   CFLAGS="$CFLAGS -Wunused-parameter "
2376   # These interfere with building main() { return 0; }, which autoconf
2377   # likes to use as its default program.
2378   CFLAGS="$CFLAGS -Wold-style-definition -Wmissing-declarations"
2379
2380   if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2381     AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2382   fi
2383   if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2384     AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2385   fi
2386   if test "$tor_cv_cflags__warn_unused_const_variable_2" = "yes"; then
2387     AC_DEFINE([HAVE_CFLAG_WUNUSED_CONST_VARIABLE], 1, [True if we have -Wunused-const-variable])
2388   fi
2389
2390   if test "x$enable_fatal_warnings" = "xyes"; then
2391     # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2392     # default autoconf programs are full of errors.
2393     CFLAGS="$CFLAGS -Werror"
2394   fi
2395
2396 fi
2397
2398 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2399    case "$host_os" in
2400     darwin*)
2401       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.])
2402    esac
2403 fi
2404
2405 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2406
2407 AC_CONFIG_FILES([
2408         Doxyfile
2409         Makefile
2410         config.rust
2411         contrib/dist/suse/tor.sh
2412         contrib/operator-tools/tor.logrotate
2413         contrib/dist/tor.sh
2414         contrib/dist/torctl
2415         contrib/dist/tor.service
2416         src/config/torrc.sample
2417         src/config/torrc.minimal
2418         src/rust/.cargo/config
2419         scripts/maint/checkOptionDocs.pl
2420         scripts/maint/updateVersions.pl
2421 ])
2422
2423 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2424   regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2425   for file in $regular_mans ; do
2426     if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2427       echo "==================================";
2428       echo;
2429       echo "Building Tor has failed since manpages cannot be built.";
2430       echo;
2431       echo "You need asciidoc installed to be able to build the manpages.";
2432       echo "To build without manpages, use the --disable-asciidoc argument";
2433       echo "when calling configure.";
2434       echo;
2435       echo "==================================";
2436       exit 1;
2437     fi
2438   done
2439 fi
2440
2441 if test "$fragile_hardening" = "yes"; then
2442   AC_MSG_WARN([
2443
2444 ============
2445 Warning!  Building Tor with --enable-fragile-hardening (also known as
2446 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2447 other kinds of attacks easier. A Tor instance build with this option will be
2448 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2449 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2450 denial of service attacks. For more information, see
2451 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening
2452 ============
2453   ])
2454 fi
2455
2456 AC_OUTPUT