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