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