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