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