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