configure.ac

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