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