1 dnl Copyright (c) 2001-2004, Roger Dingledine
2 dnl Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson
3 dnl Copyright (c) 2007-2018, The Tor Project, Inc.
4 dnl See LICENSE for licensing information
7 AC_INIT([tor],[0.3.5.0-alpha-dev])
8 AC_CONFIG_SRCDIR([src/app/main/tor_main.c])
9 AC_CONFIG_MACRO_DIR([m4])
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])
16 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
17 AC_CONFIG_HEADERS([orconfig.h])
19 AC_USE_SYSTEM_EXTENSIONS
24 AC_ARG_ENABLE(openbsd-malloc,
25 AS_HELP_STRING(--enable-openbsd-malloc, [use malloc code from OpenBSD. Linux only]))
26 AC_ARG_ENABLE(static-openssl,
27 AS_HELP_STRING(--enable-static-openssl, [link against a static openssl library. Requires --with-openssl-dir]))
28 AC_ARG_ENABLE(static-libevent,
29 AS_HELP_STRING(--enable-static-libevent, [link against a static libevent library. Requires --with-libevent-dir]))
30 AC_ARG_ENABLE(static-zlib,
31 AS_HELP_STRING(--enable-static-zlib, [link against a static zlib library. Requires --with-zlib-dir]))
32 AC_ARG_ENABLE(static-tor,
33 AS_HELP_STRING(--enable-static-tor, [create an entirely static Tor binary. Requires --with-openssl-dir and --with-libevent-dir and --with-zlib-dir]))
34 AC_ARG_ENABLE(unittests,
35 AS_HELP_STRING(--disable-unittests, [don't build unit tests for Tor. Risky!]))
36 AC_ARG_ENABLE(coverage,
37 AS_HELP_STRING(--enable-coverage, [enable coverage support in the unit-test build]))
38 AC_ARG_ENABLE(asserts-in-tests,
39 AS_HELP_STRING(--disable-asserts-in-tests, [disable tor_assert() calls in the unit tests, for branch coverage]))
40 AC_ARG_ENABLE(system-torrc,
41 AS_HELP_STRING(--disable-system-torrc, [don't look for a system-wide torrc file]))
42 AC_ARG_ENABLE(libfuzzer,
43 AS_HELP_STRING(--enable-libfuzzer, [build extra fuzzers based on 'libfuzzer']))
44 AC_ARG_ENABLE(oss-fuzz,
45 AS_HELP_STRING(--enable-oss-fuzz, [build extra fuzzers based on 'oss-fuzz' environment]))
46 AC_ARG_ENABLE(memory-sentinels,
47 AS_HELP_STRING(--disable-memory-sentinels, [disable code that tries to prevent some kinds of memory access bugs. For fuzzing only.]))
49 AS_HELP_STRING(--enable-rust, [enable rust integration]))
50 AC_ARG_ENABLE(cargo-online-mode,
51 AS_HELP_STRING(--enable-cargo-online-mode, [Allow cargo to make network requests to fetch crates. For builds with rust only.]))
52 AC_ARG_ENABLE(restart-debugging,
53 AS_HELP_STRING(--enable-restart-debugging, [Build Tor with support for debugging in-process restart. Developers only.]))
54 AC_ARG_ENABLE(zstd-advanced-apis,
55 AS_HELP_STRING(--disable-zstd-advanced-apis, [Build without support for zstd's "static-only" APIs.]))
57 if test "x$enable_coverage" != "xyes" -a "x$enable_asserts_in_tests" = "xno" ; then
58 AC_MSG_ERROR([Can't disable assertions outside of coverage build])
61 AM_CONDITIONAL(UNITTESTS_ENABLED, test "x$enable_unittests" != "xno")
62 AM_CONDITIONAL(COVERAGE_ENABLED, test "x$enable_coverage" = "xyes")
63 AM_CONDITIONAL(DISABLE_ASSERTS_IN_UNIT_TESTS, test "x$enable_asserts_in_tests" = "xno")
64 AM_CONDITIONAL(LIBFUZZER_ENABLED, test "x$enable_libfuzzer" = "xyes")
65 AM_CONDITIONAL(OSS_FUZZ_ENABLED, test "x$enable_oss_fuzz" = "xyes")
66 AM_CONDITIONAL(USE_RUST, test "x$enable_rust" = "xyes")
68 if test "$enable_static_tor" = "yes"; then
69 enable_static_libevent="yes";
70 enable_static_openssl="yes";
71 enable_static_zlib="yes";
72 CFLAGS="$CFLAGS -static"
75 if test "$enable_system_torrc" = "no"; then
76 AC_DEFINE(DISABLE_SYSTEM_TORRC, 1,
77 [Defined if we're not going to look for a torrc in SYSCONF])
80 if test "$enable_memory_sentinels" = "no"; then
81 AC_DEFINE(DISABLE_MEMORY_SENTINELS, 1,
82 [Defined if we're turning off memory safety code to look for bugs])
85 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
87 AC_ARG_ENABLE(asciidoc,
88 AS_HELP_STRING(--disable-asciidoc, [don't use asciidoc (disables building of manpages)]),
89 [case "${enableval}" in
90 "yes") asciidoc=true ;;
91 "no") asciidoc=false ;;
92 *) AC_MSG_ERROR(bad value for --disable-asciidoc) ;;
93 esac], [asciidoc=true])
95 # systemd notify support
96 AC_ARG_ENABLE(systemd,
97 AS_HELP_STRING(--enable-systemd, [enable systemd notification support]),
98 [case "${enableval}" in
99 "yes") systemd=true ;;
100 "no") systemd=false ;;
101 * ) AC_MSG_ERROR(bad value for --enable-systemd) ;;
102 esac], [systemd=auto])
104 if test "$enable_restart_debugging" = "yes"; then
105 AC_DEFINE(ENABLE_RESTART_DEBUGGING, 1,
106 [Defined if we're building with support for in-process restart debugging.])
109 if test "$enable_zstd_advanced_apis" != "no"; then
110 AC_DEFINE(ENABLE_ZSTD_ADVANCED_APIS, 1,
111 [Defined if we're going to try to use zstd's "static-only" APIs.])
115 if test "x$enable_systemd" = "xno"; then
118 PKG_CHECK_MODULES(SYSTEMD,
122 if test "x$have_systemd" = "xno"; then
123 AC_MSG_NOTICE([Okay, checking for systemd a different way...])
124 PKG_CHECK_MODULES(SYSTEMD,
131 if test "x$have_systemd" = "xyes"; then
132 AC_DEFINE(HAVE_SYSTEMD,1,[Have systemd])
133 TOR_SYSTEMD_CFLAGS="${SYSTEMD_CFLAGS}"
134 TOR_SYSTEMD_LIBS="${SYSTEMD_LIBS}"
135 PKG_CHECK_MODULES(LIBSYSTEMD209, [libsystemd >= 209],
136 [AC_DEFINE(HAVE_SYSTEMD_209,1,[Have systemd v209 or more])], [])
138 AC_SUBST(TOR_SYSTEMD_CFLAGS)
139 AC_SUBST(TOR_SYSTEMD_LIBS)
141 if test "x$enable_systemd" = "xyes" -a "x$have_systemd" != "xyes" ; then
142 AC_MSG_ERROR([Explicitly requested systemd support, but systemd not found])
147 AC_DEFINE(_REENTRANT, 1, [Define on some platforms to activate x_r() functions in time.h])
151 AC_ARG_ENABLE(gcc-warnings,
152 AS_HELP_STRING(--enable-gcc-warnings, [deprecated alias for enable-fatal-warnings]))
153 AC_ARG_ENABLE(fatal-warnings,
154 AS_HELP_STRING(--enable-fatal-warnings, [tell the compiler to treat all warnings as errors.]))
155 AC_ARG_ENABLE(gcc-warnings-advisory,
156 AS_HELP_STRING(--disable-gcc-warnings-advisory, [disable the regular verbose warnings]))
158 dnl Others suggest '/gs /safeseh /nxcompat /dynamicbase' for non-gcc on Windows
159 AC_ARG_ENABLE(gcc-hardening,
160 AS_HELP_STRING(--disable-gcc-hardening, [disable compiler security checks]))
162 dnl Deprecated --enable-expensive-hardening but keep it for now for backward compat.
163 AC_ARG_ENABLE(expensive-hardening,
164 AS_HELP_STRING(--enable-expensive-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
165 AC_ARG_ENABLE(fragile-hardening,
166 AS_HELP_STRING(--enable-fragile-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
167 if test "x$enable_expensive_hardening" = "xyes" || test "x$enable_fragile_hardening" = "xyes"; then
168 fragile_hardening="yes"
169 AC_DEFINE(DEBUG_SMARTLIST, 1, [Enable smartlist debugging])
172 dnl Linker hardening options
173 dnl Currently these options are ELF specific - you can't use this with MacOSX
174 AC_ARG_ENABLE(linker-hardening,
175 AS_HELP_STRING(--disable-linker-hardening, [disable linker security fixups]))
177 AC_ARG_ENABLE(local-appdata,
178 AS_HELP_STRING(--enable-local-appdata, [default to host local application data paths on Windows]))
179 if test "$enable_local_appdata" = "yes"; then
180 AC_DEFINE(ENABLE_LOCAL_APPDATA, 1,
181 [Defined if we default to host local appdata paths on Windows])
185 AC_ARG_ENABLE(tor2web-mode,
186 AS_HELP_STRING(--enable-tor2web-mode, [support tor2web non-anonymous mode]),
187 [if test "x$enableval" = "xyes"; then
188 CFLAGS="$CFLAGS -D ENABLE_TOR2WEB_MODE=1"
191 AC_ARG_ENABLE(tool-name-check,
192 AS_HELP_STRING(--disable-tool-name-check, [check for sanely named toolchain when cross-compiling]))
194 AC_ARG_ENABLE(seccomp,
195 AS_HELP_STRING(--disable-seccomp, [do not attempt to use libseccomp]))
197 AC_ARG_ENABLE(libscrypt,
198 AS_HELP_STRING(--disable-libscrypt, [do not attempt to use libscrypt]))
200 dnl Enable event tracing which are transformed to debug log statement.
201 AC_ARG_ENABLE(event-tracing-debug,
202 AS_HELP_STRING(--enable-event-tracing-debug, [build with event tracing to debug log]))
203 AM_CONDITIONAL([USE_EVENT_TRACING_DEBUG], [test "x$enable_event_tracing_debug" = "xyes"])
205 if test x$enable_event_tracing_debug = xyes; then
206 AC_DEFINE([USE_EVENT_TRACING_DEBUG], [1], [Tracing framework to log debug])
207 AC_DEFINE([TOR_EVENT_TRACING_ENABLED], [1], [Compile the event tracing instrumentation])
210 dnl Enable Android only features.
211 AC_ARG_ENABLE(android,
212 AS_HELP_STRING(--enable-android, [build with Android features enabled]))
213 AM_CONDITIONAL([USE_ANDROID], [test "x$enable_android" = "xyes"])
215 if test "x$enable_android" = "xyes"; then
216 AC_DEFINE([USE_ANDROID], [1], [Compile with Android specific features enabled])
218 dnl Check if the Android log library is available.
219 AC_CHECK_HEADERS([android/log.h])
220 AC_SEARCH_LIBS(__android_log_write, [log])
225 dnl Tor modules options. These options are namespaced with --disable-module-XXX
229 m4_define(MODULES, dirauth)
231 dnl Directory Authority module.
232 AC_ARG_ENABLE([module-dirauth],
233 AS_HELP_STRING([--disable-module-dirauth],
234 [Do not build tor with the dirauth module]),
235 [], dnl Action if-given
236 AC_DEFINE([HAVE_MODULE_DIRAUTH], [1],
237 [Compile with Directory Authority feature support]))
238 AM_CONDITIONAL(BUILD_MODULE_DIRAUTH, [test "x$enable_module_dirauth" != "xno"])
240 dnl Helper variables.
241 TOR_MODULES_ALL_ENABLED=
242 AC_DEFUN([ADD_MODULE], [
243 MODULE=m4_toupper($1)
244 TOR_MODULES_ALL_ENABLED="${TOR_MODULES_ALL_ENABLED} -DHAVE_MODULE_${MODULE}=1"
246 m4_foreach_w([module], MODULES, [ADD_MODULE([module])])
247 AC_SUBST(TOR_MODULES_ALL_ENABLED)
249 dnl check for the correct "ar" when cross-compiling.
250 dnl (AM_PROG_AR was new in automake 1.11.2, which we do not yet require,
251 dnl so kludge up a replacement for the case where it isn't there yet.)
252 m4_ifdef([AM_PROG_AR],
254 [AN_MAKEVAR([AR], [AC_PROG_AR])
255 AN_PROGRAM([ar], [AC_PROG_AR])
256 AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL([AR], [ar], [:])])
259 dnl Check whether the above macro has settled for a simply named tool even
260 dnl though we're cross compiling. We must do this before running AC_PROG_CC,
261 dnl because that will find any cc on the system, not only the cross-compiler,
262 dnl and then verify that a binary built with this compiler runs on the
263 dnl build system. It will then come to the false conclusion that we're not
265 if test "x$enable_tool_name_check" != "xno"; then
266 if test "x$ac_tool_warned" = "xyes"; then
267 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.)])
268 elif test "x$ac_ct_AR" != "x" -a "x$cross_compiling" = "xmaybe"; then
269 AC_MSG_ERROR([We think we are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
279 AC_ARG_VAR([PERL], [path to Perl binary])
280 AC_CHECK_PROGS([PERL], [perl])
281 AM_CONDITIONAL(USE_PERL, [test "x$ac_cv_prog_PERL" != "x"])
283 dnl check for asciidoc and a2x
284 AC_PATH_PROG([ASCIIDOC], [asciidoc], none)
285 AC_PATH_PROGS([A2X], [a2x a2x.py], none)
287 AM_CONDITIONAL(USE_ASCIIDOC, test "x$asciidoc" = "xtrue")
292 AC_ARG_VAR([PYTHON], [path to Python binary])
293 AC_CHECK_PROGS(PYTHON, [ \
295 python3.8 python3.7 python3.6 python3.5 python3.4 \
298 if test "x$PYTHON" = "x"; then
299 AC_MSG_WARN([Python unavailable; some tests will not be run.])
301 AM_CONDITIONAL(USEPYTHON, [test "x$PYTHON" != "x"])
303 dnl List all external rust crates we depend on here. Include the version
308 AC_SUBST(rust_crates)
310 ifdef([AC_C_FLEXIBLE_ARRAY_MEMBER], [
311 AC_C_FLEXIBLE_ARRAY_MEMBER
313 dnl Maybe we've got an old autoconf...
314 AC_CACHE_CHECK([for flexible array members],
318 struct abc { int a; char b[]; };
320 struct abc *def = malloc(sizeof(struct abc)+sizeof(char));
323 [tor_cv_c_flexarray=yes],
324 [tor_cv_c_flexarray=no])])
325 if test "$tor_cv_flexarray" = "yes"; then
326 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
328 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
332 AC_CACHE_CHECK([for working C99 mid-block declaration syntax],
335 [AC_LANG_PROGRAM([], [int x; x = 3; int y; y = 4 + x;])],
336 [tor_cv_c_c99_decl=yes],
337 [tor_cv_c_c99_decl=no] )])
338 if test "$tor_cv_c_c99_decl" != "yes"; then
339 AC_MSG_ERROR([Your compiler doesn't support c99 mid-block declarations. This is required as of Tor 0.2.6.x])
342 AC_CACHE_CHECK([for working C99 designated initializers],
343 tor_cv_c_c99_designated_init,
345 [AC_LANG_PROGRAM([struct s { int a; int b; };],
346 [[ struct s ss = { .b = 5, .a = 6 }; ]])],
347 [tor_cv_c_c99_designated_init=yes],
348 [tor_cv_c_c99_designated_init=no] )])
350 if test "$tor_cv_c_c99_designated_init" != "yes"; then
351 AC_MSG_ERROR([Your compiler doesn't support c99 designated initializers. This is required as of Tor 0.2.6.x])
355 AC_ARG_WITH(tor-user,
356 AS_HELP_STRING(--with-tor-user=NAME, [specify username for tor daemon]),
364 AC_ARG_WITH(tor-group,
365 AS_HELP_STRING(--with-tor-group=NAME, [specify group name for tor daemon]),
373 dnl If _WIN32 is defined and non-zero, we are building for win32
374 AC_MSG_CHECKING([for win32])
375 AC_RUN_IFELSE([AC_LANG_SOURCE([
376 int main(int c, char **v) {
387 bwin32=true; AC_MSG_RESULT([yes]),
388 bwin32=false; AC_MSG_RESULT([no]),
389 bwin32=cross; AC_MSG_RESULT([cross])
392 if test "$bwin32" = "cross"; then
393 AC_MSG_CHECKING([for win32 (cross)])
394 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
396 int main(int c, char **v) {return 0;}
399 int main(int c, char **v) {return x(y);}
402 bwin32=true; AC_MSG_RESULT([yes]),
403 bwin32=false; AC_MSG_RESULT([no]))
408 /* Defined to access windows functions and definitions for >=WinXP */
410 # define WINVER 0x0501
413 /* Defined to access _other_ windows functions and definitions for >=WinXP */
414 # ifndef _WIN32_WINNT
415 # define _WIN32_WINNT 0x0501
418 /* Defined to avoid including some windows headers as part of Windows.h */
419 # ifndef WIN32_LEAN_AND_MEAN
420 # define WIN32_LEAN_AND_MEAN 1
425 AM_CONDITIONAL(WIN32, test "x$bwin32" = "xtrue")
426 AM_CONDITIONAL(BUILD_NT_SERVICES, test "x$bwin32" = "xtrue")
427 AM_CONDITIONAL(BUILD_LIBTORRUNNER, test "x$bwin32" != "xtrue")
429 dnl Enable C99 when compiling with MIPSpro
430 AC_MSG_CHECKING([for MIPSpro compiler])
431 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [
432 #if (defined(__sgi) && defined(_COMPILER_VERSION))
437 bmipspro=false; AC_MSG_RESULT(no),
438 bmipspro=true; AC_MSG_RESULT(yes))
440 if test "$bmipspro" = "true"; then
441 CFLAGS="$CFLAGS -c99"
446 AC_ARG_VAR([TOR_RUST_TARGET], [Rust target, must be specified when cross-compiling (HOST != BUILD). example: i686-pc-windows-gnu])
448 if test "x$enable_rust" = "xyes"; then
449 AC_ARG_VAR([RUSTC], [path to the rustc binary])
450 AC_CHECK_PROG([RUSTC], [rustc], [rustc],[no])
451 if test "x$RUSTC" = "xno"; then
452 AC_MSG_ERROR([rustc unavailable but rust integration requested.])
455 AC_ARG_VAR([CARGO], [path to the cargo binary])
456 AC_CHECK_PROG([CARGO], [cargo], [cargo],[no])
457 if test "x$CARGO" = "xno"; then
458 AC_MSG_ERROR([cargo unavailable but rust integration requested.])
461 AC_DEFINE([HAVE_RUST], 1, [have Rust])
462 if test "x$enable_fatal_warnings" = "xyes"; then
467 if test "x$enable_cargo_online_mode" = "xyes"; then
471 CARGO_ONLINE=--frozen
474 dnl When we're not allowed to touch the network, we need crate dependencies
475 dnl locally available.
476 AC_MSG_CHECKING([rust crate dependencies])
477 AC_ARG_VAR([TOR_RUST_DEPENDENCIES], [path to directory with local crate mirror])
478 if test "x$TOR_RUST_DEPENDENCIES" = "x"; then
479 TOR_RUST_DEPENDENCIES="${srcdir}/src/ext/rust/crates"
481 dnl Check whether the path exists before we try to cd into it.
482 if test ! -d "$TOR_RUST_DEPENDENCIES"; then
483 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.])
486 dnl Make the path absolute, since we'll be using it from within a
488 TOR_RUST_DEPENDENCIES=$(cd "$TOR_RUST_DEPENDENCIES" ; pwd)
490 for dep in $rust_crates; do
491 if test ! -d "$TOR_RUST_DEPENDENCIES"/"$dep"; then
492 AC_MSG_ERROR([Failure to find rust dependency $TOR_RUST_DEPENDENCIES/$dep. Specify a dependency directory using the TOR_RUST_DEPENDENCIES variable or allow cargo to fetch crates using --enable-cargo-online-mode.])
496 if test "x$ERRORED" = "x"; then
501 dnl This is a workaround for #46797
502 dnl (a.k.a https://github.com/rust-lang/rust/issues/46797 ). Once the
503 dnl upstream bug is fixed, we can remove this workaround.
506 TOR_RUST_EXTRA_LIBS="-lresolv"
510 dnl For now both MSVC and MinGW rust libraries will output static libs with
511 dnl the MSVC naming convention.
512 if test "$bwin32" = "true"; then
513 tor_rust_static_name=tor_rust.lib
515 tor_rust_static_name=libtor_rust.a
520 if test -n "$TOR_RUST_TARGET"; then
521 if test "$host" = "$build"; then
522 AC_MSG_ERROR([HOST = BUILD is invalid if TOR_RUST_TARGET is specified, see configure --help for more information.])
524 RUST_TARGET_PROP="target = '$TOR_RUST_TARGET'"
525 TOR_RUST_LIB_PATH="src/rust/target/$TOR_RUST_TARGET/release/$tor_rust_static_name"
527 if test "$host" != "$build"; then
528 AC_MSG_ERROR([TOR_RUST_TARGET must be specified when cross-compiling with Rust enabled.])
531 TOR_RUST_LIB_PATH="src/rust/target/release/$tor_rust_static_name"
534 AC_SUBST(RUST_TARGET_PROP)
535 AC_SUBST(TOR_RUST_LIB_PATH)
536 AC_SUBST(CARGO_ONLINE)
540 dnl Let's check the rustc version, too
541 AC_MSG_CHECKING([rust version])
542 RUSTC_VERSION=`$RUSTC --version`
543 RUSTC_VERSION_MAJOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 1`
544 RUSTC_VERSION_MINOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 2`
545 if test "x$RUSTC_VERSION_MAJOR" = "x" -o "x$RUSTC_VERSION_MINOR" = "x"; then
546 AC_MSG_ERROR([rustc version couldn't be identified])
548 if test "$RUSTC_VERSION_MAJOR" -lt 2 -a "$RUSTC_VERSION_MINOR" -lt 14; then
549 AC_MSG_ERROR([rustc must be at least version 1.14])
551 AC_MSG_RESULT([$RUSTC_VERSION])
554 AC_SUBST(TOR_RUST_EXTRA_LIBS)
556 AC_SEARCH_LIBS(socket, [socket network])
557 AC_SEARCH_LIBS(gethostbyname, [nsl])
558 AC_SEARCH_LIBS(dlopen, [dl])
559 AC_SEARCH_LIBS(inet_aton, [resolv])
560 AC_SEARCH_LIBS(backtrace, [execinfo])
562 AC_SEARCH_LIBS([clock_gettime], [rt])
563 if test "$LIBS" != "$saved_LIBS"; then
564 # Looks like we need -lrt for clock_gettime().
568 AC_SEARCH_LIBS(pthread_create, [pthread])
569 AC_SEARCH_LIBS(pthread_detach, [pthread])
571 AM_CONDITIONAL(THREADS_WIN32, test "$bwin32" = "true")
572 AM_CONDITIONAL(THREADS_PTHREADS, test "$bwin32" = "false")
576 RtlSecureZeroMemory \
580 backtrace_symbols_fd \
586 get_current_dir_name \
595 gnu_get_libc_version \
603 mach_approximate_time \
632 # Apple messed up when they added two functions functions in Sierra: they
633 # forgot to decorate them with appropriate AVAILABLE_MAC_OS_VERSION
634 # checks. So we should only probe for those functions if we are sure that we
635 # are not targeting OSX 10.11 or earlier.
636 AC_MSG_CHECKING([for a pre-Sierra OSX build target])
637 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
639 # include <AvailabilityMacros.h>
640 # ifndef MAC_OS_X_VERSION_10_12
641 # define MAC_OS_X_VERSION_10_12 101200
643 # if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
644 # if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
645 # error "Running on Mac OSX 10.11 or earlier"
650 [on_macos_pre_10_12=no ; AC_MSG_RESULT([no])],
651 [on_macos_pre_10_12=yes; AC_MSG_RESULT([yes])])
653 if test "$on_macos_pre_10_12" = "no"; then
660 if test "$bwin32" != "true"; then
661 AC_CHECK_HEADERS(pthread.h)
662 AC_CHECK_FUNCS(pthread_create)
663 AC_CHECK_FUNCS(pthread_condattr_setclock)
666 if test "$bwin32" = "true"; then
667 AC_CHECK_DECLS([SecureZeroMemory, _getwch], , , [
674 AM_CONDITIONAL(BUILD_READPASSPHRASE_C,
675 test "x$ac_cv_func_readpassphrase" = "xno" && test "$bwin32" = "false")
677 AC_MSG_CHECKING([whether free(NULL) works])
678 AC_RUN_IFELSE([AC_LANG_PROGRAM([
684 [free_null_ok=true; AC_MSG_RESULT(yes)],
685 [free_null_ok=false; AC_MSG_RESULT(no)],
686 [free_null_ok=cross; AC_MSG_RESULT(cross)])
688 if test "$free_null_ok" = "false"; then
689 AC_MSG_ERROR([Your libc implementation doesn't allow free(NULL), as required by C99.])
692 dnl ------------------------------------------------------
693 dnl Where do you live, libevent? And how do we call you?
695 if test "$bwin32" = "true"; then
696 TOR_LIB_WS32=-lws2_32
697 TOR_LIB_IPHLPAPI=-liphlpapi
698 # Some of the cargo-cults recommend -lwsock32 as well, but I don't
699 # think it's actually necessary.
701 TOR_LIB_USERENV=-luserenv
707 AC_SUBST(TOR_LIB_WS32)
708 AC_SUBST(TOR_LIB_GDI)
709 AC_SUBST(TOR_LIB_IPHLPAPI)
710 AC_SUBST(TOR_LIB_USERENV)
712 tor_libevent_pkg_redhat="libevent"
713 tor_libevent_pkg_debian="libevent-dev"
714 tor_libevent_devpkg_redhat="libevent-devel"
715 tor_libevent_devpkg_debian="libevent-dev"
717 dnl On Gnu/Linux or any place we require it, we'll add librt to the Libevent
718 dnl linking for static builds.
719 STATIC_LIBEVENT_FLAGS=""
720 if test "$enable_static_libevent" = "yes"; then
721 if test "$have_rt" = "yes"; then
722 STATIC_LIBEVENT_FLAGS=" -lrt "
726 TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32], [
728 #include <winsock2.h>
730 #include <sys/time.h>
731 #include <sys/types.h>
732 #include <event2/event.h>], [
734 #include <winsock2.h>
737 struct event_base *event_base_new(void);
738 void event_base_free(struct event_base *);],
741 {WSADATA d; WSAStartup(0x101,&d); }
743 event_base_free(event_base_new());
744 ], [--with-libevent-dir], [/opt/libevent])
746 dnl Determine the incantation needed to link libevent.
748 save_LDFLAGS="$LDFLAGS"
749 save_CPPFLAGS="$CPPFLAGS"
751 LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
752 LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
753 CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
755 AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
757 if test "$enable_static_libevent" = "yes"; then
758 if test "$tor_cv_library_libevent_dir" = "(system)"; then
759 AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
761 TOR_LIBEVENT_LIBS="$TOR_LIBDIR_libevent/libevent.a $STATIC_LIBEVENT_FLAGS"
764 if test "x$ac_cv_header_event2_event_h" = "xyes"; then
765 AC_SEARCH_LIBS(event_new, [event event_core], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for event_new"))
766 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"))
768 if test "$ac_cv_search_event_new" != "none required"; then
769 TOR_LIBEVENT_LIBS="$ac_cv_search_event_new"
771 if test "$ac_cv_search_evdns_base_new" != "none required"; then
772 TOR_LIBEVENT_LIBS="$ac_cv_search_evdns_base_new $TOR_LIBEVENT_LIBS"
775 AC_MSG_ERROR("libevent2 is required but the headers could not be found")
779 dnl Now check for particular libevent functions.
780 AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file \
781 evutil_secure_rng_add_bytes \
785 LDFLAGS="$save_LDFLAGS"
786 CPPFLAGS="$save_CPPFLAGS"
788 dnl Check that libevent is at least at version 2.0.10, the first stable
789 dnl release of its series
790 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
791 AC_MSG_CHECKING([whether Libevent is new enough])
792 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
793 #include <event2/event.h>
794 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
800 ])], [ AC_MSG_RESULT([yes]) ],
801 [ AC_MSG_RESULT([no])
802 AC_MSG_ERROR([Libevent is not new enough. We require 2.0.10-stable or later]) ] )
805 LDFLAGS="$save_LDFLAGS"
806 CPPFLAGS="$save_CPPFLAGS"
808 AC_SUBST(TOR_LIBEVENT_LIBS)
810 dnl ------------------------------------------------------
811 dnl Where do you live, libm?
813 dnl On some platforms (Haiku/BeOS) the math library is
814 dnl part of libroot. In which case don't link against lm
817 AC_SEARCH_LIBS(pow, [m], , AC_MSG_ERROR([Could not find pow in libm or libc.]))
818 if test "$ac_cv_search_pow" != "none required"; then
819 TOR_LIB_MATH="$ac_cv_search_pow"
822 AC_SUBST(TOR_LIB_MATH)
824 dnl ------------------------------------------------------
825 dnl Where do you live, openssl? And how do we call you?
827 tor_openssl_pkg_redhat="openssl"
828 tor_openssl_pkg_debian="libssl-dev"
829 tor_openssl_devpkg_redhat="openssl-devel"
830 tor_openssl_devpkg_debian="libssl-dev"
832 ALT_openssl_WITHVAL=""
834 AS_HELP_STRING(--with-ssl-dir=PATH, [obsolete alias for --with-openssl-dir]),
836 if test "x$withval" != "xno" && test "x$withval" != "x"; then
837 ALT_openssl_WITHVAL="$withval"
841 AC_MSG_NOTICE([Now, we'll look for OpenSSL >= 1.0.1])
842 TOR_SEARCH_LIBRARY(openssl, $tryssldir, [-lssl -lcrypto $TOR_LIB_GDI $TOR_LIB_WS32],
843 [#include <openssl/ssl.h>
844 char *getenv(const char *);],
845 [struct ssl_cipher_st;
846 unsigned SSL_CIPHER_get_id(const struct ssl_cipher_st *);
847 char *getenv(const char *);],
848 dnl This funny-looking test program calls getenv, so that the compiler
849 dnl will neither make code that call SSL_CIPHER_get_id(NULL) [producing
850 dnl a crash], nor optimize out the call to SSL_CIPHER_get_id().
851 dnl We look for SSL_cipher_get_id() because it is present in
852 dnl OpenSSL >=1.0.1, because it is not deprecated, and because Tor
854 [if (getenv("THIS_SHOULDNT_BE_SET_X201803")) SSL_CIPHER_get_id((void *)0);], [],
855 [/usr/local/opt/openssl /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /opt/openssl])
857 dnl XXXX check for OPENSSL_VERSION_NUMBER == SSLeay()
859 if test "$enable_static_openssl" = "yes"; then
860 if test "$tor_cv_library_openssl_dir" = "(system)"; then
861 AC_MSG_ERROR("You must specify an explicit --with-openssl-dir=x option when using --enable-static-openssl")
863 TOR_OPENSSL_LIBS="$TOR_LIBDIR_openssl/libssl.a $TOR_LIBDIR_openssl/libcrypto.a"
866 TOR_OPENSSL_LIBS="-lssl -lcrypto"
868 AC_SUBST(TOR_OPENSSL_LIBS)
870 dnl Now check for particular openssl functions.
872 save_LDFLAGS="$LDFLAGS"
873 save_CPPFLAGS="$CPPFLAGS"
874 LIBS="$TOR_OPENSSL_LIBS $LIBS"
875 LDFLAGS="$TOR_LDFLAGS_openssl $LDFLAGS"
876 CPPFLAGS="$TOR_CPPFLAGS_openssl $CPPFLAGS"
878 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
879 #include <openssl/opensslv.h>
880 #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x1000100fL
885 [ 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.]) ])
887 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
888 #include <openssl/opensslv.h>
889 #include <openssl/evp.h>
890 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_ECDSA)
893 #if !defined(NID_X9_62_prime256v1) || !defined(NID_secp224r1)
894 #error "curves unavailable"
898 [ 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.]) ])
900 AC_CHECK_MEMBERS([struct ssl_method_st.get_cipher_by_char], , ,
901 [#include <openssl/ssl.h>
905 SSL_SESSION_get_master_key \
906 SSL_get_server_random \
907 SSL_get_client_ciphers \
908 SSL_get_client_random \
913 dnl Check if OpenSSL has scrypt implementation.
914 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
916 dnl Check if OpenSSL structures are opaque
917 AC_CHECK_MEMBERS([SSL.state], , ,
918 [#include <openssl/ssl.h>
921 AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT()
922 #include <openssl/sha.h>
925 dnl Define the set of checks for KIST scheduler support.
926 AC_DEFUN([CHECK_KIST_SUPPORT],[
927 dnl KIST needs struct tcp_info and for certain members to exist.
929 [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
930 , ,[[#include <netinet/tcp.h>]])
931 dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
932 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
933 #include <linux/sockios.h>
937 ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
938 if test "x$have_siocoutqnsd" = "xyes"; then
939 if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
940 if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
941 have_kist_support=yes
946 dnl Now, trigger the check.
948 AS_IF([test "x$have_kist_support" = "xyes"],
949 [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
951 [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
954 LDFLAGS="$save_LDFLAGS"
955 CPPFLAGS="$save_CPPFLAGS"
957 dnl ------------------------------------------------------
958 dnl Where do you live, zlib? And how do we call you?
960 tor_zlib_pkg_redhat="zlib"
961 tor_zlib_pkg_debian="zlib1g"
962 tor_zlib_devpkg_redhat="zlib-devel"
963 tor_zlib_devpkg_debian="zlib1g-dev"
965 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
967 [const char * zlibVersion(void);],
968 [zlibVersion();], [--with-zlib-dir],
971 if test "$enable_static_zlib" = "yes"; then
972 if test "$tor_cv_library_zlib_dir" = "(system)"; then
973 AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
974 using --enable-static-zlib")
976 TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
981 AC_SUBST(TOR_ZLIB_LIBS)
983 dnl ------------------------------------------------------
984 dnl Where we do we find lzma?
987 AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
988 [case "${enableval}" in
991 * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
994 if test "x$enable_lzma" = "xno"; then
997 PKG_CHECK_MODULES([LZMA],
1002 if test "x$have_lzma" = "xno" ; then
1003 AC_MSG_WARN([Unable to find liblzma.])
1007 if test "x$have_lzma" = "xyes"; then
1008 AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
1009 TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
1010 TOR_LZMA_LIBS="${LZMA_LIBS}"
1012 AC_SUBST(TOR_LZMA_CFLAGS)
1013 AC_SUBST(TOR_LZMA_LIBS)
1015 dnl ------------------------------------------------------
1016 dnl Where we do we find zstd?
1019 AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
1020 [case "${enableval}" in
1023 * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
1026 if test "x$enable_zstd" = "xno"; then
1029 PKG_CHECK_MODULES([ZSTD],
1034 if test "x$have_zstd" = "xno" ; then
1035 AC_MSG_WARN([Unable to find libzstd.])
1039 if test "x$have_zstd" = "xyes"; then
1040 AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
1041 TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
1042 TOR_ZSTD_LIBS="${ZSTD_LIBS}"
1044 dnl now check for zstd functions
1046 save_CFLAGS="$CFLAGS"
1047 LIBS="$LIBS $ZSTD_LIBS"
1048 CFLAGS="$CFLAGS $ZSTD_CFLAGS"
1049 AC_CHECK_FUNCS(ZSTD_estimateCStreamSize \
1050 ZSTD_estimateDCtxSize)
1052 CFLAGS="$save_CFLAGS"
1054 AC_SUBST(TOR_ZSTD_CFLAGS)
1055 AC_SUBST(TOR_ZSTD_LIBS)
1057 dnl ----------------------------------------------------------------------
1058 dnl Check if libcap is available for capabilities.
1060 tor_cap_pkg_debian="libcap2"
1061 tor_cap_pkg_redhat="libcap"
1062 tor_cap_devpkg_debian="libcap-dev"
1063 tor_cap_devpkg_redhat="libcap-devel"
1065 AC_CHECK_LIB([cap], [cap_init], [],
1066 AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
1068 AC_CHECK_FUNCS(cap_set_proc)
1070 dnl ---------------------------------------------------------------------
1071 dnl Now that we know about our major libraries, we can check for compiler
1072 dnl and linker hardening options. We need to do this with the libraries known,
1073 dnl since sometimes the linker will like an option but not be willing to
1074 dnl use it with a build of a library.
1076 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
1077 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"
1085 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1086 #if !defined(__clang__)
1088 #endif])], have_clang=yes, have_clang=no)
1090 if test "x$enable_gcc_hardening" != "xno"; then
1091 CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
1092 if test "x$have_clang" = "xyes"; then
1093 TOR_CHECK_CFLAGS(-Qunused-arguments)
1095 TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
1096 AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
1097 AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1098 m4_ifdef([AS_VAR_IF],[
1099 AS_VAR_IF(can_compile, [yes],
1100 AS_VAR_IF(can_link, [yes],
1102 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.)]))
1104 AS_VAR_POPDEF([can_link])
1105 AS_VAR_POPDEF([can_compile])
1106 TOR_CHECK_CFLAGS(-Wstack-protector)
1107 TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1108 if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1109 TOR_CHECK_CFLAGS(-fPIE)
1110 TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1112 TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1115 if test "$fragile_hardening" = "yes"; then
1116 TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1117 if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1118 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.])
1121 if test "$tor_cv_cflags__ftrapv" != "yes"; then
1122 AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1125 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1126 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1127 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*])
1130 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1131 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1132 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*])
1135 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1138 dnl Find the correct libraries to add in order to use the sanitizers.
1140 dnl When building Rust, Cargo will run the linker with the -nodefaultlibs
1141 dnl option, which will prevent the compiler from linking the sanitizer
1142 dnl libraries it needs. We need to specify them manually.
1144 dnl What's more, we need to specify them in a linker script rather than
1145 dnl from build.rs: these options aren't allowed in the cargo:rustc-flags
1147 RUST_LINKER_OPTIONS=""
1148 if test "x$have_clang" = "xyes"; then
1149 if test "x$CFLAGS_ASAN" != "x"; then
1150 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS $CFLAGS_ASAN"
1152 if test "x$CFLAGS_UBSAN" != "x"; then
1153 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS $CFLAGS_UBSAN"
1156 if test "x$CFLAGS_ASAN" != "x"; then
1157 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -lasan"
1159 if test "x$CFLAGS_UBSAN" != "x"; then
1160 RUST_LINKER_OPTIONS="$RUST_LINKER_OPTIONS -lubsan"
1163 AC_SUBST(RUST_LINKER_OPTIONS)
1165 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1166 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1168 mulodi_fixes_ftrapv=no
1169 if test "$have_clang" = "yes"; then
1170 saved_CFLAGS="$CFLAGS"
1171 CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1172 AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1177 int main(int argc, char **argv)
1179 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1180 * (int64_t)atoi(argv[3]);
1183 [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1184 [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1185 if test "$ftrapv_can_link" = "no"; then
1186 AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1191 int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1195 int main(int argc, char **argv)
1197 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1198 * (int64_t)atoi(argv[3]);
1201 [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1202 [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1204 CFLAGS="$saved_CFLAGS"
1207 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1209 dnl These cflags add bunches of branches, and we haven't been able to
1210 dnl persuade ourselves that they're suitable for code that needs to be
1212 AC_SUBST(CFLAGS_BUGTRAP)
1213 dnl These cflags are variant ones sutable for code that needs to be
1215 AC_SUBST(CFLAGS_CONSTTIME)
1217 if test "x$enable_linker_hardening" != "xno"; then
1218 TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1221 # For backtrace support
1222 TOR_CHECK_LDFLAGS(-rdynamic)
1224 dnl ------------------------------------------------------
1225 dnl Now see if we have a -fomit-frame-pointer compiler option.
1227 saved_CFLAGS="$CFLAGS"
1228 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1229 F_OMIT_FRAME_POINTER=''
1230 if test "$saved_CFLAGS" != "$CFLAGS"; then
1231 if test "$fragile_hardening" = "yes"; then
1232 F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1235 CFLAGS="$saved_CFLAGS"
1236 AC_SUBST(F_OMIT_FRAME_POINTER)
1238 dnl ------------------------------------------------------
1239 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1240 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1241 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1243 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1245 dnl ============================================================
1246 dnl Check for libseccomp
1248 if test "x$enable_seccomp" != "xno"; then
1249 AC_CHECK_HEADERS([seccomp.h])
1250 AC_SEARCH_LIBS(seccomp_init, [seccomp])
1253 dnl ============================================================
1254 dnl Check for libscrypt
1256 if test "x$enable_libscrypt" != "xno"; then
1257 AC_CHECK_HEADERS([libscrypt.h])
1258 AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1259 AC_CHECK_FUNCS([libscrypt_scrypt])
1262 dnl ============================================================
1263 dnl We need an implementation of curve25519.
1265 dnl set these defaults.
1266 build_curve25519_donna=no
1267 build_curve25519_donna_c64=no
1268 use_curve25519_donna=no
1269 use_curve25519_nacl=no
1272 dnl The best choice is using curve25519-donna-c64, but that requires
1274 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1275 tor_cv_can_use_curve25519_donna_c64,
1277 [AC_LANG_PROGRAM([dnl
1279 typedef unsigned uint128_t __attribute__((mode(TI)));
1280 int func(uint64_t a, uint64_t b) {
1281 uint128_t c = ((uint128_t)a) * b;
1282 int ok = ((uint64_t)(c>>96)) == 522859 &&
1283 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1284 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1285 (((uint64_t)(c))&0xffffffffL) == 0;
1289 int ok = func( ((uint64_t)2000000000) * 1000000000,
1290 ((uint64_t)1234567890) << 24);
1293 [tor_cv_can_use_curve25519_donna_c64=yes],
1294 [tor_cv_can_use_curve25519_donna_c64=no],
1296 [AC_LANG_PROGRAM([dnl
1298 typedef unsigned uint128_t __attribute__((mode(TI)));
1299 int func(uint64_t a, uint64_t b) {
1300 uint128_t c = ((uint128_t)a) * b;
1301 int ok = ((uint64_t)(c>>96)) == 522859 &&
1302 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1303 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1304 (((uint64_t)(c))&0xffffffffL) == 0;
1308 int ok = func( ((uint64_t)2000000000) * 1000000000,
1309 ((uint64_t)1234567890) << 24);
1312 [tor_cv_can_use_curve25519_donna_c64=cross],
1313 [tor_cv_can_use_curve25519_donna_c64=no])])])
1315 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1316 nacl/crypto_scalarmult_curve25519.h])
1318 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1319 tor_cv_can_use_curve25519_nacl,
1320 [tor_saved_LIBS="$LIBS"
1323 [AC_LANG_PROGRAM([dnl
1324 #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1325 #include <crypto_scalarmult_curve25519.h>
1326 #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1327 #include <nacl/crypto_scalarmult_curve25519.h>
1329 #ifdef crypto_scalarmult_curve25519_ref_BYTES
1330 #error Hey, this is the reference implementation! That's not fast.
1333 unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1334 ])], [tor_cv_can_use_curve25519_nacl=yes],
1335 [tor_cv_can_use_curve25519_nacl=no])
1336 LIBS="$tor_saved_LIBS" ])
1338 dnl Okay, now we need to figure out which one to actually use. Fall back
1339 dnl to curve25519-donna.c
1341 if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1342 build_curve25519_donna_c64=yes
1343 use_curve25519_donna=yes
1344 elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1345 use_curve25519_nacl=yes
1346 CURVE25519_LIBS=-lnacl
1348 build_curve25519_donna=yes
1349 use_curve25519_donna=yes
1352 if test "x$use_curve25519_donna" = "xyes"; then
1353 AC_DEFINE(USE_CURVE25519_DONNA, 1,
1354 [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1356 if test "x$use_curve25519_nacl" = "xyes"; then
1357 AC_DEFINE(USE_CURVE25519_NACL, 1,
1358 [Defined if we should use a curve25519 from nacl])
1360 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1361 test "x$build_curve25519_donna" = "xyes")
1362 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1363 test "x$build_curve25519_donna_c64" = "xyes")
1364 AC_SUBST(CURVE25519_LIBS)
1366 dnl Make sure to enable support for large off_t if available.
1369 AC_CHECK_HEADERS([errno.h \
1383 gnu/libc-version.h \
1422 AC_CHECK_HEADERS(sys/param.h)
1424 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1425 [#ifdef HAVE_SYS_TYPES_H
1426 #include <sys/types.h>
1428 #ifdef HAVE_SYS_SOCKET_H
1429 #include <sys/socket.h>
1431 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1432 [#ifdef HAVE_SYS_TYPES_H
1433 #include <sys/types.h>
1435 #ifdef HAVE_SYS_SOCKET_H
1436 #include <sys/socket.h>
1438 #ifdef HAVE_NET_IF_H
1441 #ifdef HAVE_NETINET_IN_H
1442 #include <netinet/in.h>
1445 AC_CHECK_HEADERS(linux/if.h,[],[],
1447 #ifdef HAVE_SYS_SOCKET_H
1448 #include <sys/socket.h>
1452 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1453 linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1454 [#ifdef HAVE_SYS_TYPES_H
1455 #include <sys/types.h>
1457 #ifdef HAVE_SYS_SOCKET_H
1458 #include <sys/socket.h>
1460 #ifdef HAVE_LIMITS_H
1463 #ifdef HAVE_LINUX_TYPES_H
1464 #include <linux/types.h>
1466 #ifdef HAVE_NETINET_IN6_H
1467 #include <netinet/in6.h>
1469 #ifdef HAVE_NETINET_IN_H
1470 #include <netinet/in.h>
1473 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1474 linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1475 [#ifdef HAVE_SYS_TYPES_H
1476 #include <sys/types.h>
1478 #ifdef HAVE_SYS_SOCKET_H
1479 #include <sys/socket.h>
1481 #ifdef HAVE_LIMITS_H
1484 #ifdef HAVE_LINUX_TYPES_H
1485 #include <linux/types.h>
1487 #ifdef HAVE_NETINET_IN6_H
1488 #include <netinet/in6.h>
1490 #ifdef HAVE_NETINET_IN_H
1491 #include <netinet/in.h>
1493 #ifdef HAVE_LINUX_IF_H
1494 #include <linux/if.h>
1498 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1501 if test "x$linux_netfilter_ipv4" = "x1"; then
1504 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1507 if test "x$transparent_ok" = "x1"; then
1508 AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1510 AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1513 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1514 [#ifdef HAVE_SYS_TYPES_H
1515 #include <sys/types.h>
1517 #ifdef HAVE_SYS_TIME_H
1518 #include <sys/time.h>
1521 AC_CHECK_SIZEOF(char)
1522 AC_CHECK_SIZEOF(short)
1523 AC_CHECK_SIZEOF(int)
1524 AC_CHECK_SIZEOF(long)
1525 AC_CHECK_SIZEOF(long long)
1526 AC_CHECK_SIZEOF(__int64)
1527 AC_CHECK_SIZEOF(void *)
1528 AC_CHECK_SIZEOF(time_t)
1529 AC_CHECK_SIZEOF(size_t)
1530 AC_CHECK_SIZEOF(pid_t)
1532 AC_CHECK_TYPES([uint, u_char, ssize_t])
1534 AC_PC_FROM_UCONTEXT([:])
1536 dnl used to include sockaddr_storage, but everybody has that.
1537 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1538 [#ifdef HAVE_SYS_TYPES_H
1539 #include <sys/types.h>
1541 #ifdef HAVE_NETINET_IN_H
1542 #include <netinet/in.h>
1544 #ifdef HAVE_NETINET_IN6_H
1545 #include <netinet/in6.h>
1547 #ifdef HAVE_SYS_SOCKET_H
1548 #include <sys/socket.h>
1551 #define _WIN32_WINNT 0x0501
1552 #define WIN32_LEAN_AND_MEAN
1553 #include <winsock2.h>
1554 #include <ws2tcpip.h>
1557 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1558 [#ifdef HAVE_SYS_TYPES_H
1559 #include <sys/types.h>
1561 #ifdef HAVE_NETINET_IN_H
1562 #include <netinet/in.h>
1564 #ifdef HAVE_NETINET_IN6_H
1565 #include <netinet/in6.h>
1567 #ifdef HAVE_SYS_SOCKET_H
1568 #include <sys/socket.h>
1571 #define _WIN32_WINNT 0x0501
1572 #define WIN32_LEAN_AND_MEAN
1573 #include <winsock2.h>
1574 #include <ws2tcpip.h>
1578 AC_CHECK_TYPES([rlim_t], , ,
1579 [#ifdef HAVE_SYS_TYPES_H
1580 #include <sys/types.h>
1582 #ifdef HAVE_SYS_TIME_H
1583 #include <sys/time.h>
1585 #ifdef HAVE_SYS_RESOURCE_H
1586 #include <sys/resource.h>
1590 AX_CHECK_SIGN([time_t],
1593 #ifdef HAVE_SYS_TYPES_H
1594 #include <sys/types.h>
1596 #ifdef HAVE_SYS_TIME_H
1597 #include <sys/time.h>
1604 if test "$ax_cv_decl_time_t_signed" = "no"; then
1605 AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1608 AX_CHECK_SIGN([size_t],
1609 [ tor_cv_size_t_signed=yes ],
1610 [ tor_cv_size_t_signed=no ], [
1611 #ifdef HAVE_SYS_TYPES_H
1612 #include <sys/types.h>
1616 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1617 AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1620 AX_CHECK_SIGN([enum always],
1621 [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1623 enum always { AAA, BBB, CCC };
1626 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1627 #ifdef HAVE_SYS_SOCKET_H
1628 #include <sys/socket.h>
1632 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1634 AC_CHECK_SIZEOF(cell_t)
1636 # Now make sure that NULL can be represented as zero bytes.
1637 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1638 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1639 [[#include <stdlib.h>
1642 #ifdef HAVE_STDDEF_H
1645 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1646 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1647 [tor_cv_null_is_zero=yes],
1648 [tor_cv_null_is_zero=no],
1649 [tor_cv_null_is_zero=cross])])
1651 if test "$tor_cv_null_is_zero" = "cross"; then
1652 # Cross-compiling; let's hope that the target isn't raving mad.
1653 AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1656 if test "$tor_cv_null_is_zero" != "no"; then
1657 AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1658 [Define to 1 iff memset(0) sets pointers to NULL])
1661 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1662 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1663 [[#include <stdlib.h>
1666 #ifdef HAVE_STDDEF_H
1669 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1670 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1671 [tor_cv_dbl0_is_zero=yes],
1672 [tor_cv_dbl0_is_zero=no],
1673 [tor_cv_dbl0_is_zero=cross])])
1675 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1676 # Cross-compiling; let's hope that the target isn't raving mad.
1677 AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1680 if test "$tor_cv_dbl0_is_zero" != "no"; then
1681 AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1682 [Define to 1 iff memset(0) sets doubles to 0.0])
1685 # And what happens when we malloc zero?
1686 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1687 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1688 [[#include <stdlib.h>
1691 #ifdef HAVE_STDDEF_H
1694 int main () { return malloc(0)?0:1; }]])],
1695 [tor_cv_malloc_zero_works=yes],
1696 [tor_cv_malloc_zero_works=no],
1697 [tor_cv_malloc_zero_works=cross])])
1699 if test "$tor_cv_malloc_zero_works" = "cross"; then
1700 # Cross-compiling; let's hope that the target isn't raving mad.
1701 AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1704 if test "$tor_cv_malloc_zero_works" = "yes"; then
1705 AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1706 [Define to 1 iff malloc(0) returns a pointer])
1709 # whether we seem to be in a 2s-complement world.
1710 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1711 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1712 [[int main () { int problem = ((-99) != (~99)+1);
1713 return problem ? 1 : 0; }]])],
1714 [tor_cv_twos_complement=yes],
1715 [tor_cv_twos_complement=no],
1716 [tor_cv_twos_complement=cross])])
1718 if test "$tor_cv_twos_complement" = "cross"; then
1719 # Cross-compiling; let's hope that the target isn't raving mad.
1720 AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1723 if test "$tor_cv_twos_complement" != "no"; then
1724 AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1725 [Define to 1 iff we represent negative integers with
1729 # What does shifting a negative value do?
1730 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1731 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1732 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1733 [tor_cv_sign_extend=yes],
1734 [tor_cv_sign_extend=no],
1735 [tor_cv_sign_extend=cross])])
1737 if test "$tor_cv_sign_extend" = "cross"; then
1738 # Cross-compiling; let's hope that the target isn't raving mad.
1739 AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1742 if test "$tor_cv_sign_extend" != "no"; then
1743 AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1744 [Define to 1 iff right-shifting a negative value performs sign-extension])
1747 # Is uint8_t the same type as unsigned char?
1748 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1749 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1752 unsigned char c;]])],
1753 [tor_cv_uint8_uchar=yes],
1754 [tor_cv_uint8_uchar=no],
1755 [tor_cv_uint8_uchar=cross])])
1757 if test "$tor_cv_uint8_uchar" = "cross"; then
1758 AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1761 if test "$tor_cv_uint8_uchar" = "no"; then
1762 AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1765 AC_ARG_WITH(tcmalloc,
1766 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library]),
1767 [ tcmalloc=yes ], [ tcmalloc=no ])
1769 if test "x$tcmalloc" = "xyes"; then
1770 LDFLAGS="-ltcmalloc $LDFLAGS"
1773 using_custom_malloc=no
1774 if test "x$enable_openbsd_malloc" = "xyes"; then
1775 using_custom_malloc=yes
1777 if test "x$tcmalloc" = "xyes"; then
1778 using_custom_malloc=yes
1780 if test "$using_custom_malloc" = "no"; then
1781 AC_CHECK_FUNCS(mallinfo)
1784 # By default, we're going to assume we don't have mlockall()
1785 # bionic and other platforms have various broken mlockall subsystems.
1786 # Some systems don't have a working mlockall, some aren't linkable,
1787 # and some have it but don't declare it.
1788 AC_CHECK_FUNCS(mlockall)
1789 AC_CHECK_DECLS([mlockall], , , [
1790 #ifdef HAVE_SYS_MMAN_H
1791 #include <sys/mman.h>
1794 # Allow user to specify an alternate syslog facility
1795 AC_ARG_WITH(syslog-facility,
1796 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1797 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1798 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1799 AC_SUBST(LOGFACILITY)
1801 # Check if we have getresuid and getresgid
1802 AC_CHECK_FUNCS(getresuid getresgid)
1804 # Check for gethostbyname_r in all its glorious incompatible versions.
1805 # (This logic is based on that in Python's configure.in)
1806 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1807 [Define this if you have any gethostbyname_r()])
1809 AC_CHECK_FUNC(gethostbyname_r, [
1810 AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1812 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1813 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1817 struct hostent *h1, *h2;
1819 (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1821 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1822 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1823 [Define this if gethostbyname_r takes 6 arguments])
1826 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1832 (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1834 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1835 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1836 [Define this if gethostbyname_r takes 5 arguments])
1839 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1844 struct hostent_data hd;
1845 (void) gethostbyname_r(cp1,h1,&hd);
1847 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1848 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1849 [Define this if gethostbyname_r takes 3 arguments])
1859 AC_CACHE_CHECK([whether the C compiler supports __func__],
1860 tor_cv_have_func_macro,
1861 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1863 int main(int c, char **v) { puts(__func__); }])],
1864 tor_cv_have_func_macro=yes,
1865 tor_cv_have_func_macro=no))
1867 AC_CACHE_CHECK([whether the C compiler supports __FUNC__],
1868 tor_cv_have_FUNC_macro,
1869 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1871 int main(int c, char **v) { puts(__FUNC__); }])],
1872 tor_cv_have_FUNC_macro=yes,
1873 tor_cv_have_FUNC_macro=no))
1875 AC_CACHE_CHECK([whether the C compiler supports __FUNCTION__],
1876 tor_cv_have_FUNCTION_macro,
1877 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1879 int main(int c, char **v) { puts(__FUNCTION__); }])],
1880 tor_cv_have_FUNCTION_macro=yes,
1881 tor_cv_have_FUNCTION_macro=no))
1883 AC_CACHE_CHECK([whether we have extern char **environ already declared],
1884 tor_cv_have_environ_declared,
1885 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1886 #ifdef HAVE_UNISTD_H
1890 int main(int c, char **v) { char **t = environ; }])],
1891 tor_cv_have_environ_declared=yes,
1892 tor_cv_have_environ_declared=no))
1894 if test "$tor_cv_have_func_macro" = "yes"; then
1895 AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
1898 if test "$tor_cv_have_FUNC_macro" = "yes"; then
1899 AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
1902 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
1903 AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
1904 [Defined if the compiler supports __FUNCTION__])
1907 if test "$tor_cv_have_environ_declared" = "yes"; then
1908 AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
1909 [Defined if we have extern char **environ already declared])
1912 # $prefix stores the value of the --prefix command line option, or
1913 # NONE if the option wasn't set. In the case that it wasn't set, make
1914 # it be the default, so that we can use it to expand directories now.
1915 if test "x$prefix" = "xNONE"; then
1916 prefix=$ac_default_prefix
1919 # and similarly for $exec_prefix
1920 if test "x$exec_prefix" = "xNONE"; then
1924 if test "x$BUILDDIR" = "x"; then
1928 AH_TEMPLATE([BUILDDIR],[tor's build directory])
1929 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
1931 if test "x$SRCDIR" = "x"; then
1932 SRCDIR=$(cd "$srcdir"; pwd)
1934 AH_TEMPLATE([SRCDIR],[tor's sourcedir directory])
1935 AC_DEFINE_UNQUOTED(SRCDIR,"$SRCDIR")
1937 if test "x$CONFDIR" = "x"; then
1938 CONFDIR=`eval echo $sysconfdir/tor`
1941 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
1942 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
1944 BINDIR=`eval echo $bindir`
1946 LOCALSTATEDIR=`eval echo $localstatedir`
1947 AC_SUBST(LOCALSTATEDIR)
1949 if test "$bwin32" = "true"; then
1950 # Test if the linker supports the --nxcompat and --dynamicbase options
1952 save_LDFLAGS="$LDFLAGS"
1953 LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
1954 AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
1955 AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
1956 [AC_MSG_RESULT([yes])]
1957 [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
1958 [AC_MSG_RESULT([no])]
1960 LDFLAGS="$save_LDFLAGS"
1963 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
1964 # than autoconf's macros like.
1965 if test "$GCC" = "yes"; then
1966 # Disable GCC's strict aliasing checks. They are an hours-to-debug
1967 # accident waiting to happen.
1968 CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
1970 # Override optimization level for non-gcc compilers
1972 enable_gcc_warnings=no
1973 enable_gcc_warnings_advisory=no
1976 # Warnings implies advisory-warnings and -Werror.
1977 if test "$enable_gcc_warnings" = "yes"; then
1978 enable_gcc_warnings_advisory=yes
1979 enable_fatal_warnings=yes
1982 # OS X Lion started deprecating the system openssl. Let's just disable
1983 # all deprecation warnings on OS X. Also, to potentially make the binary
1984 # a little smaller, let's enable dead_strip.
1988 CFLAGS="$CFLAGS -Wno-deprecated-declarations"
1989 LDFLAGS="$LDFLAGS -dead_strip" ;;
1992 # Add some more warnings which we use in development but not in the
1993 # released versions. (Some relevant gcc versions can't handle these.)
1995 # Note that we have to do this near the end of the autoconf process, or
1996 # else we may run into problems when these warnings hit on the testing C
1997 # programs that autoconf wants to build.
1998 if test "x$enable_gcc_warnings_advisory" != "xno"; then
2001 *-*-openbsd* | *-*-bitrig*)
2002 # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
2003 # That's fine, except that the headers don't pass -Wredundant-decls.
2004 # Therefore, let's disable -Wsystem-headers when we're building
2005 # with maximal warnings on OpenBSD.
2006 CFLAGS="$CFLAGS -Wno-system-headers" ;;
2009 # GCC4.3 users once report trouble with -Wstrict-overflow=5. GCC5 users
2010 # have it work better.
2011 # CFLAGS="$CFLAGS -Wstrict-overflow=1"
2013 # This warning was added in gcc 4.3, but it appears to generate
2014 # spurious warnings in gcc 4.4. I don't know if it works in 4.5.
2015 #CFLAGS="$CFLAGS -Wlogical-op"
2017 m4_foreach_w([warning_flag], [
2019 -Waddress-of-array-temporary
2020 -Waddress-of-temporary
2022 -Wanonymous-pack-parens
2025 -Warc-bridge-casts-disallowed-in-nonarc
2026 -Warc-maybe-repeated-use-of-weak
2027 -Warc-performSelector-leaks
2028 -Warc-repeated-use-of-weak
2030 -Warray-bounds-pointer-arithmetic
2032 -Wasm-operand-widths
2034 -Watomic-property-with-user-defined-accessor
2036 -Wauto-storage-class
2039 -Wbackslash-newline-escape
2040 -Wbad-array-new-length
2041 -Wbind-to-temporary-copy
2042 -Wbitfield-constant-conversion
2045 -Wbuiltin-requires-header
2047 -Wcompare-distinct-pointer-types
2048 -Wcomplex-component-init
2049 -Wconditional-type-mismatch
2051 -Wconstant-conversion
2052 -Wconstant-logical-operand
2053 -Wconstexpr-not-const
2054 -Wcustom-atomic-properties
2056 -Wdangling-initializer-list
2058 -Wdelegating-ctor-cycles
2059 -Wdeprecated-implementations
2060 -Wdeprecated-register
2061 -Wdirect-ivar-access
2063 -Wdistributed-object-modifiers
2065 -Wdollar-in-identifier-extension
2067 -Wduplicate-decl-specifier
2069 -Wduplicate-method-arg
2070 -Wduplicate-method-match
2072 -Wdynamic-class-memaccess
2073 -Wembedded-directive
2074 -Wempty-translation-unit
2076 -Wexit-time-destructors
2077 -Wexplicit-ownership-type
2078 -Wextern-initializer
2082 -Wflexible-array-extensions
2085 -Wfour-char-constants
2087 -Wglobal-constructors
2088 -Wgnu-array-member-paren-init
2090 -Wgnu-static-float-init
2093 -Widiomatic-parentheses
2094 -Wignored-attributes
2095 -Wimplicit-atomic-properties
2096 -Wimplicit-conversion-floating-point-to-bool
2097 -Wimplicit-exception-spec-mismatch
2098 -Wimplicit-fallthrough
2099 -Wimplicit-fallthrough-per-function
2100 -Wimplicit-retain-self
2101 -Wimport-preprocessor-directive-pedantic
2102 -Wincompatible-library-redeclaration
2103 -Wincompatible-pointer-types-discards-qualifiers
2104 -Wincomplete-implementation
2106 -Wincomplete-umbrella
2109 -Wint-to-void-pointer-cast
2115 -Winvalid-source-encoding
2116 -Winvalid-token-paste
2117 -Wknr-promoted-parameter
2118 -Wlarge-by-value-copy
2119 -Wliteral-conversion
2121 -Wlocal-type-template-args
2125 -Wmalformed-warning-check
2129 -Wmismatched-parameter-types
2130 -Wmismatched-return-types
2131 -Wmissing-field-initializers
2132 -Wmissing-format-attribute
2134 -Wmissing-selector-name
2136 -Wmissing-variable-declarations
2140 -Wnon-literal-null-conversion
2142 -Wnonportable-cfstrings
2148 -Wout-of-line-declaration
2150 -Woverlength-strings
2152 -Woverriding-method-mismatch
2153 -Wpointer-type-mismatch
2154 -Wpredefined-identifier-outside-function
2155 -Wprotocol-property-synthesis-ambiguity
2156 -Wreadonly-iboutlet-property
2157 -Wreadonly-setter-attrs
2159 -Wreceiver-forward-class
2161 -Wreinterpret-base-class
2162 -Wrequires-super-attribute
2163 -Wreserved-user-defined-literal
2164 -Wreturn-stack-address
2166 -Wselector-type-mismatch
2168 -Wserialized-diagnostics
2170 -Wshift-count-negative
2171 -Wshift-count-overflow
2172 -Wshift-negative-value
2174 -Wshift-sign-overflow
2176 -Wsizeof-array-argument
2177 -Wsource-uses-openmp
2180 -Wstatic-local-in-inline
2184 -Wstrlcpy-strlcat-size
2186 -Wsuggest-attribute=format
2187 -Wsuggest-attribute=noreturn
2188 -Wsuper-class-method-mismatch
2191 -Wtautological-constant-out-of-range-compare
2192 -Wtentative-definition-incomplete-type
2195 -Wtypedef-redefinition
2198 -Wundefined-internal
2199 -Wundefined-reinterpret-cast
2201 -Wunicode-whitespace
2202 -Wunknown-warning-option
2203 -Wunnamed-type-template-args
2204 -Wunneeded-member-function
2206 -Wunsupported-visibility
2207 -Wunused-but-set-parameter
2208 -Wunused-but-set-variable
2209 -Wunused-command-line-argument
2210 -Wunused-const-variable=2
2211 -Wunused-exception-parameter
2212 -Wunused-local-typedefs
2213 -Wunused-member-function
2214 -Wunused-sanitize-argument
2215 -Wunused-volatile-lvalue
2216 -Wuser-defined-literals
2219 -Wvector-conversions
2224 ], [ TOR_CHECK_CFLAGS([warning_flag]) ])
2226 dnl We should re-enable this in some later version. Clang doesn't
2227 dnl mind, but it causes trouble with GCC.
2228 dnl -Wstrict-overflow=2
2230 dnl These seem to require annotations that we don't currently use,
2231 dnl and they give false positives in our pthreads wrappers. (Clang 4)
2233 dnl -Wthread-safety-analysis
2234 dnl -Wthread-safety-attributes
2235 dnl -Wthread-safety-beta
2236 dnl -Wthread-safety-precise
2238 CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2239 CFLAGS="$CFLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2240 CFLAGS="$CFLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2241 CFLAGS="$CFLAGS -Wwrite-strings"
2242 CFLAGS="$CFLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2243 CFLAGS="$CFLAGS -Waggregate-return -Wpacked -Wunused"
2244 CFLAGS="$CFLAGS -Wunused-parameter "
2245 # These interfere with building main() { return 0; }, which autoconf
2246 # likes to use as its default program.
2247 CFLAGS="$CFLAGS -Wold-style-definition -Wmissing-declarations"
2249 if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2250 AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2252 if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2253 AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2256 if test "x$enable_fatal_warnings" = "xyes"; then
2257 # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2258 # default autoconf programs are full of errors.
2259 CFLAGS="$CFLAGS -Werror"
2264 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2267 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.])
2271 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2278 contrib/dist/suse/tor.sh
2279 contrib/operator-tools/tor.logrotate
2282 contrib/dist/tor.service
2283 src/config/torrc.sample
2284 src/config/torrc.minimal
2285 src/rust/.cargo/config
2286 scripts/maint/checkOptionDocs.pl
2287 scripts/maint/updateVersions.pl
2290 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2291 regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2292 for file in $regular_mans ; do
2293 if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2294 echo "==================================";
2296 echo "Building Tor has failed since manpages cannot be built.";
2298 echo "You need asciidoc installed to be able to build the manpages.";
2299 echo "To build without manpages, use the --disable-asciidoc argument";
2300 echo "when calling configure.";
2302 echo "==================================";
2308 if test "$fragile_hardening" = "yes"; then
2312 Warning! Building Tor with --enable-fragile-hardening (also known as
2313 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2314 other kinds of attacks easier. A Tor instance build with this option will be
2315 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2316 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2317 denial of service attacks. For more information, see
2318 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening