configure.ac

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