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
7 AC_INIT([tor],[0.3.4.0-alpha-dev])
8 AC_CONFIG_SRCDIR([src/or/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 if test -f "/etc/redhat-release"; then
25 if test -f "/usr/kerberos/include"; then
26 CPPFLAGS="$CPPFLAGS -I/usr/kerberos/include"
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"
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.]))
59 AS_HELP_STRING(--enable-rust, [enable rust integration]))
60 AC_ARG_ENABLE(cargo-online-mode,
61 AS_HELP_STRING(--enable-cargo-online-mode, [Allow cargo to make network requests to fetch crates. For builds with rust only.]))
62 AC_ARG_ENABLE(restart-debugging,
63 AS_HELP_STRING(--enable-restart-debugging, [Build Tor with support for debugging in-process restart. Developers only.]))
64 AC_ARG_ENABLE(zstd-advanced-apis,
65 AS_HELP_STRING(--disable-zstd-advanced-apis, [Build without support for zstd's "static-only" APIs.]))
67 if test "x$enable_coverage" != "xyes" -a "x$enable_asserts_in_tests" = "xno" ; then
68 AC_MSG_ERROR([Can't disable assertions outside of coverage build])
71 AM_CONDITIONAL(UNITTESTS_ENABLED, test "x$enable_unittests" != "xno")
72 AM_CONDITIONAL(COVERAGE_ENABLED, test "x$enable_coverage" = "xyes")
73 AM_CONDITIONAL(DISABLE_ASSERTS_IN_UNIT_TESTS, test "x$enable_asserts_in_tests" = "xno")
74 AM_CONDITIONAL(LIBFUZZER_ENABLED, test "x$enable_libfuzzer" = "xyes")
75 AM_CONDITIONAL(OSS_FUZZ_ENABLED, test "x$enable_oss_fuzz" = "xyes")
76 AM_CONDITIONAL(USE_RUST, test "x$enable_rust" = "xyes")
78 if test "$enable_static_tor" = "yes"; then
79 enable_static_libevent="yes";
80 enable_static_openssl="yes";
81 enable_static_zlib="yes";
82 CFLAGS="$CFLAGS -static"
85 if test "$enable_system_torrc" = "no"; then
86 AC_DEFINE(DISABLE_SYSTEM_TORRC, 1,
87 [Defined if we're not going to look for a torrc in SYSCONF])
90 if test "$enable_memory_sentinels" = "no"; then
91 AC_DEFINE(DISABLE_MEMORY_SENTINELS, 1,
92 [Defined if we're turning off memory safety code to look for bugs])
95 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
97 AC_ARG_ENABLE(asciidoc,
98 AS_HELP_STRING(--disable-asciidoc, [don't use asciidoc (disables building of manpages)]),
99 [case "${enableval}" in
100 "yes") asciidoc=true ;;
101 "no") asciidoc=false ;;
102 *) AC_MSG_ERROR(bad value for --disable-asciidoc) ;;
103 esac], [asciidoc=true])
105 # systemd notify support
106 AC_ARG_ENABLE(systemd,
107 AS_HELP_STRING(--enable-systemd, [enable systemd notification support]),
108 [case "${enableval}" in
109 "yes") systemd=true ;;
110 "no") systemd=false ;;
111 * ) AC_MSG_ERROR(bad value for --enable-systemd) ;;
112 esac], [systemd=auto])
114 if test "$enable_restart_debugging" = "yes"; then
115 AC_DEFINE(ENABLE_RESTART_DEBUGGING, 1,
116 [Defined if we're building with support for in-process restart debugging.])
119 if test "$enable_zstd_advanced_apis" != "no"; then
120 AC_DEFINE(ENABLE_ZSTD_ADVANCED_APIS, 1,
121 [Defined if we're going to try to use zstd's "static-only" APIs.])
125 if test "x$enable_systemd" = "xno"; then
128 PKG_CHECK_MODULES(SYSTEMD,
132 if test "x$have_systemd" = "xno"; then
133 AC_MSG_NOTICE([Okay, checking for systemd a different way...])
134 PKG_CHECK_MODULES(SYSTEMD,
141 if test "x$have_systemd" = "xyes"; then
142 AC_DEFINE(HAVE_SYSTEMD,1,[Have systemd])
143 TOR_SYSTEMD_CFLAGS="${SYSTEMD_CFLAGS}"
144 TOR_SYSTEMD_LIBS="${SYSTEMD_LIBS}"
145 PKG_CHECK_MODULES(LIBSYSTEMD209, [libsystemd >= 209],
146 [AC_DEFINE(HAVE_SYSTEMD_209,1,[Have systemd v209 or more])], [])
148 AC_SUBST(TOR_SYSTEMD_CFLAGS)
149 AC_SUBST(TOR_SYSTEMD_LIBS)
151 if test "x$enable_systemd" = "xyes" -a "x$have_systemd" != "xyes" ; then
152 AC_MSG_ERROR([Explicitly requested systemd support, but systemd not found])
157 AC_DEFINE(_REENTRANT, 1, [Define on some platforms to activate x_r() functions in time.h])
161 AC_ARG_ENABLE(gcc-warnings,
162 AS_HELP_STRING(--enable-gcc-warnings, [deprecated alias for enable-fatal-warnings]))
163 AC_ARG_ENABLE(fatal-warnings,
164 AS_HELP_STRING(--enable-fatal-warnings, [tell the compiler to treat all warnings as errors.]))
165 AC_ARG_ENABLE(gcc-warnings-advisory,
166 AS_HELP_STRING(--disable-gcc-warnings-advisory, [disable the regular verbose warnings]))
168 dnl Others suggest '/gs /safeseh /nxcompat /dynamicbase' for non-gcc on Windows
169 AC_ARG_ENABLE(gcc-hardening,
170 AS_HELP_STRING(--disable-gcc-hardening, [disable compiler security checks]))
172 dnl Deprecated --enable-expensive-hardening but keep it for now for backward compat.
173 AC_ARG_ENABLE(expensive-hardening,
174 AS_HELP_STRING(--enable-expensive-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
175 AC_ARG_ENABLE(fragile-hardening,
176 AS_HELP_STRING(--enable-fragile-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
177 if test "x$enable_expensive_hardening" = "xyes" || test "x$enable_fragile_hardening" = "xyes"; then
178 fragile_hardening="yes"
181 dnl Linker hardening options
182 dnl Currently these options are ELF specific - you can't use this with MacOSX
183 AC_ARG_ENABLE(linker-hardening,
184 AS_HELP_STRING(--disable-linker-hardening, [disable linker security fixups]))
186 AC_ARG_ENABLE(local-appdata,
187 AS_HELP_STRING(--enable-local-appdata, [default to host local application data paths on Windows]))
188 if test "$enable_local_appdata" = "yes"; then
189 AC_DEFINE(ENABLE_LOCAL_APPDATA, 1,
190 [Defined if we default to host local appdata paths on Windows])
194 AC_ARG_ENABLE(tor2web-mode,
195 AS_HELP_STRING(--enable-tor2web-mode, [support tor2web non-anonymous mode]),
196 [if test "x$enableval" = "xyes"; then
197 CFLAGS="$CFLAGS -D ENABLE_TOR2WEB_MODE=1"
200 AC_ARG_ENABLE(tool-name-check,
201 AS_HELP_STRING(--disable-tool-name-check, [check for sanely named toolchain when cross-compiling]))
203 AC_ARG_ENABLE(seccomp,
204 AS_HELP_STRING(--disable-seccomp, [do not attempt to use libseccomp]))
206 AC_ARG_ENABLE(libscrypt,
207 AS_HELP_STRING(--disable-libscrypt, [do not attempt to use libscrypt]))
209 dnl Enable event tracing which are transformed to debug log statement.
210 AC_ARG_ENABLE(event-tracing-debug,
211 AS_HELP_STRING(--enable-event-tracing-debug, [build with event tracing to debug log]))
212 AM_CONDITIONAL([USE_EVENT_TRACING_DEBUG], [test "x$enable_event_tracing_debug" = "xyes"])
214 if test x$enable_event_tracing_debug = xyes; then
215 AC_DEFINE([USE_EVENT_TRACING_DEBUG], [1], [Tracing framework to log debug])
216 AC_DEFINE([TOR_EVENT_TRACING_ENABLED], [1], [Compile the event tracing instrumentation])
219 dnl Enable Android only features.
220 AC_ARG_ENABLE(android,
221 AS_HELP_STRING(--enable-android, [build with Android features enabled]))
222 AM_CONDITIONAL([USE_ANDROID], [test "x$enable_android" = "xyes"])
224 if test "x$enable_android" = "xyes"; then
225 AC_DEFINE([USE_ANDROID], [1], [Compile with Android specific features enabled])
227 dnl Check if the Android log library is available.
228 AC_CHECK_HEADERS([android/log.h])
229 AC_SEARCH_LIBS(__android_log_write, [log])
234 dnl Tor modules options. These options are namespaced with --disable-module-XXX
238 m4_define(MODULES, dirauth)
240 dnl Directory Authority module.
241 AC_ARG_ENABLE([module-dirauth],
242 AS_HELP_STRING([--disable-module-dirauth],
243 [Do not build tor with the dirauth module]),
244 [], dnl Action if-given
245 AC_DEFINE([HAVE_MODULE_DIRAUTH], [1],
246 [Compile with Directory Authority feature support]))
247 AM_CONDITIONAL(BUILD_MODULE_DIRAUTH, [test "x$enable_module_dirauth" != "xno"])
249 dnl Helper variables.
250 TOR_MODULES_ALL_ENABLED=
251 AC_DEFUN([ADD_MODULE], [
252 MODULE=m4_toupper($1)
253 TOR_MODULES_ALL_ENABLED="${TOR_MODULES_ALL_ENABLED} -DHAVE_MODULE_${MODULE}=1"
255 m4_foreach_w([module], MODULES, [ADD_MODULE([module])])
256 AC_SUBST(TOR_MODULES_ALL_ENABLED)
258 dnl check for the correct "ar" when cross-compiling.
259 dnl (AM_PROG_AR was new in automake 1.11.2, which we do not yet require,
260 dnl so kludge up a replacement for the case where it isn't there yet.)
261 m4_ifdef([AM_PROG_AR],
263 [AN_MAKEVAR([AR], [AC_PROG_AR])
264 AN_PROGRAM([ar], [AC_PROG_AR])
265 AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL([AR], [ar], [:])])
268 dnl Check whether the above macro has settled for a simply named tool even
269 dnl though we're cross compiling. We must do this before running AC_PROG_CC,
270 dnl because that will find any cc on the system, not only the cross-compiler,
271 dnl and then verify that a binary built with this compiler runs on the
272 dnl build system. It will then come to the false conclusion that we're not
274 if test "x$enable_tool_name_check" != "xno"; then
275 if test "x$ac_tool_warned" = "xyes"; then
276 AC_MSG_ERROR([We are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
277 elif test "x$ac_ct_AR" != "x" -a "x$cross_compiling" = "xmaybe"; then
278 AC_MSG_ERROR([We think we are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
288 AC_ARG_VAR([PERL], [path to Perl binary])
289 AC_CHECK_PROGS([PERL], [perl])
290 AM_CONDITIONAL(USE_PERL, [test "x$ac_cv_prog_PERL" != "x"])
292 dnl check for asciidoc and a2x
293 AC_PATH_PROG([ASCIIDOC], [asciidoc], none)
294 AC_PATH_PROGS([A2X], [a2x a2x.py], none)
296 AM_CONDITIONAL(USE_ASCIIDOC, test "x$asciidoc" = "xtrue")
301 AC_ARG_VAR([PYTHON], [path to Python binary])
302 AC_CHECK_PROGS(PYTHON, [python python2 python2.7 python3 python3.3])
303 if test "x$PYTHON" = "x"; then
304 AC_MSG_WARN([Python unavailable; some tests will not be run.])
306 AM_CONDITIONAL(USEPYTHON, [test "x$PYTHON" != "x"])
308 dnl List all external rust crates we depend on here. Include the version
309 rust_crates="libc-0.2.39"
310 AC_SUBST(rust_crates)
312 ifdef([AC_C_FLEXIBLE_ARRAY_MEMBER], [
313 AC_C_FLEXIBLE_ARRAY_MEMBER
315 dnl Maybe we've got an old autoconf...
316 AC_CACHE_CHECK([for flexible array members],
320 struct abc { int a; char b[]; };
322 struct abc *def = malloc(sizeof(struct abc)+sizeof(char));
325 [tor_cv_c_flexarray=yes],
326 [tor_cv_c_flexarray=no])])
327 if test "$tor_cv_flexarray" = "yes"; then
328 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
330 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
334 AC_CACHE_CHECK([for working C99 mid-block declaration syntax],
337 [AC_LANG_PROGRAM([], [int x; x = 3; int y; y = 4 + x;])],
338 [tor_cv_c_c99_decl=yes],
339 [tor_cv_c_c99_decl=no] )])
340 if test "$tor_cv_c_c99_decl" != "yes"; then
341 AC_MSG_ERROR([Your compiler doesn't support c99 mid-block declarations. This is required as of Tor 0.2.6.x])
344 AC_CACHE_CHECK([for working C99 designated initializers],
345 tor_cv_c_c99_designated_init,
347 [AC_LANG_PROGRAM([struct s { int a; int b; };],
348 [[ struct s ss = { .b = 5, .a = 6 }; ]])],
349 [tor_cv_c_c99_designated_init=yes],
350 [tor_cv_c_c99_designated_init=no] )])
352 if test "$tor_cv_c_c99_designated_init" != "yes"; then
353 AC_MSG_ERROR([Your compiler doesn't support c99 designated initializers. This is required as of Tor 0.2.6.x])
357 AC_ARG_WITH(tor-user,
358 AS_HELP_STRING(--with-tor-user=NAME, [specify username for tor daemon]),
366 AC_ARG_WITH(tor-group,
367 AS_HELP_STRING(--with-tor-group=NAME, [specify group name for tor daemon]),
375 dnl If _WIN32 is defined and non-zero, we are building for win32
376 AC_MSG_CHECKING([for win32])
377 AC_RUN_IFELSE([AC_LANG_SOURCE([
378 int main(int c, char **v) {
389 bwin32=true; AC_MSG_RESULT([yes]),
390 bwin32=false; AC_MSG_RESULT([no]),
391 bwin32=cross; AC_MSG_RESULT([cross])
394 if test "$bwin32" = "cross"; then
395 AC_MSG_CHECKING([for win32 (cross)])
396 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
398 int main(int c, char **v) {return 0;}
401 int main(int c, char **v) {return x(y);}
404 bwin32=true; AC_MSG_RESULT([yes]),
405 bwin32=false; AC_MSG_RESULT([no]))
410 /* Defined to access windows functions and definitions for >=WinXP */
412 # define WINVER 0x0501
415 /* Defined to access _other_ windows functions and definitions for >=WinXP */
416 # ifndef _WIN32_WINNT
417 # define _WIN32_WINNT 0x0501
420 /* Defined to avoid including some windows headers as part of Windows.h */
421 # ifndef WIN32_LEAN_AND_MEAN
422 # define WIN32_LEAN_AND_MEAN 1
428 AM_CONDITIONAL(BUILD_NT_SERVICES, test "x$bwin32" = "xtrue")
429 AM_CONDITIONAL(BUILD_LIBTORRUNNER, test "x$bwin32" != "xtrue")
431 dnl Enable C99 when compiling with MIPSpro
432 AC_MSG_CHECKING([for MIPSpro compiler])
433 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [
434 #if (defined(__sgi) && defined(_COMPILER_VERSION))
439 bmipspro=false; AC_MSG_RESULT(no),
440 bmipspro=true; AC_MSG_RESULT(yes))
442 if test "$bmipspro" = "true"; then
443 CFLAGS="$CFLAGS -c99"
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_cargo_online_mode" = "xyes"; then
466 CARGO_ONLINE=--frozen
469 dnl When we're not allowed to touch the network, we need crate dependencies
470 dnl locally available.
471 AC_MSG_CHECKING([rust crate dependencies])
472 AC_ARG_VAR([TOR_RUST_DEPENDENCIES], [path to directory with local crate mirror])
473 if test "x$TOR_RUST_DEPENDENCIES" = "x"; then
474 TOR_RUST_DEPENDENCIES="${srcdir}/src/ext/rust/crates"
476 dnl Check whether the path exists before we try to cd into it.
477 if test ! -d "$TOR_RUST_DEPENDENCIES"; then
478 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.])
481 dnl Make the path absolute, since we'll be using it from within a
483 TOR_RUST_DEPENDENCIES=$(cd "$TOR_RUST_DEPENDENCIES" ; pwd)
485 for dep in $rust_crates; do
486 if test ! -d "$TOR_RUST_DEPENDENCIES"/"$dep"; then
487 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.])
491 if test "x$ERRORED" = "x"; then
496 dnl This is a workaround for #46797
497 dnl (a.k.a https://github.com/rust-lang/rust/issues/46797 ). Once the
498 dnl upstream bug is fixed, we can remove this workaround.
501 TOR_RUST_EXTRA_LIBS="-lresolv"
505 dnl For now both MSVC and MinGW rust libraries will output static libs with
506 dnl the MSVC naming convention.
507 if test "$bwin32" = "true"; then
508 TOR_RUST_STATIC_NAME=tor_rust.lib
510 TOR_RUST_STATIC_NAME=libtor_rust.a
513 AC_SUBST(TOR_RUST_STATIC_NAME)
514 AC_SUBST(CARGO_ONLINE)
517 dnl Let's check the rustc version, too
518 AC_MSG_CHECKING([rust version])
519 RUSTC_VERSION=`$RUSTC --version`
520 RUSTC_VERSION_MAJOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 1`
521 RUSTC_VERSION_MINOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 2`
522 if test "x$RUSTC_VERSION_MAJOR" = "x" -o "x$RUSTC_VERSION_MINOR" = "x"; then
523 AC_MSG_ERROR([rustc version couldn't be identified])
525 if test "$RUSTC_VERSION_MAJOR" -lt 2 -a "$RUSTC_VERSION_MINOR" -lt 14; then
526 AC_MSG_ERROR([rustc must be at least version 1.14])
528 AC_MSG_RESULT([$RUSTC_VERSION])
531 AC_SUBST(TOR_RUST_EXTRA_LIBS)
533 AC_SEARCH_LIBS(socket, [socket network])
534 AC_SEARCH_LIBS(gethostbyname, [nsl])
535 AC_SEARCH_LIBS(dlopen, [dl])
536 AC_SEARCH_LIBS(inet_aton, [resolv])
537 AC_SEARCH_LIBS(backtrace, [execinfo])
539 AC_SEARCH_LIBS([clock_gettime], [rt])
540 if test "$LIBS" != "$saved_LIBS"; then
541 # Looks like we need -lrt for clock_gettime().
545 AC_SEARCH_LIBS(pthread_create, [pthread])
546 AC_SEARCH_LIBS(pthread_detach, [pthread])
548 AM_CONDITIONAL(THREADS_WIN32, test "$bwin32" = "true")
549 AM_CONDITIONAL(THREADS_PTHREADS, test "$bwin32" = "false")
553 RtlSecureZeroMemory \
557 backtrace_symbols_fd \
563 get_current_dir_name \
570 gnu_get_libc_version \
578 mach_approximate_time \
605 # Apple messed up when they added two functions functions in Sierra: they
606 # forgot to decorate them with appropriate AVAILABLE_MAC_OS_VERSION
607 # checks. So we should only probe for those 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([[
612 # include <AvailabilityMacros.h>
613 # ifndef MAC_OS_X_VERSION_10_12
614 # define MAC_OS_X_VERSION_10_12 101200
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"
623 [on_macos_pre_10_12=no ; AC_MSG_RESULT([no])],
624 [on_macos_pre_10_12=yes; AC_MSG_RESULT([yes])])
626 if test "$on_macos_pre_10_12" = "no"; then
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)
639 if test "$bwin32" = "true"; then
640 AC_CHECK_DECLS([SecureZeroMemory, _getwch], , , [
647 AM_CONDITIONAL(BUILD_READPASSPHRASE_C,
648 test "x$ac_cv_func_readpassphrase" = "xno" && test "$bwin32" = "false")
650 AC_MSG_CHECKING([whether free(NULL) works])
651 AC_RUN_IFELSE([AC_LANG_PROGRAM([
657 [free_null_ok=true; AC_MSG_RESULT(yes)],
658 [free_null_ok=false; AC_MSG_RESULT(no)],
659 [free_null_ok=cross; AC_MSG_RESULT(cross)])
661 if test "$free_null_ok" = "false"; then
662 AC_MSG_ERROR([Your libc implementation doesn't allow free(NULL), as required by C99.])
665 dnl ------------------------------------------------------
666 dnl Where do you live, libevent? And how do we call you?
668 if test "$bwin32" = "true"; then
669 TOR_LIB_WS32=-lws2_32
670 TOR_LIB_IPHLPAPI=-liphlpapi
671 # Some of the cargo-cults recommend -lwsock32 as well, but I don't
672 # think it's actually necessary.
674 TOR_LIB_USERENV=-luserenv
680 AC_SUBST(TOR_LIB_WS32)
681 AC_SUBST(TOR_LIB_GDI)
682 AC_SUBST(TOR_LIB_IPHLPAPI)
683 AC_SUBST(TOR_LIB_USERENV)
685 tor_libevent_pkg_redhat="libevent"
686 tor_libevent_pkg_debian="libevent-dev"
687 tor_libevent_devpkg_redhat="libevent-devel"
688 tor_libevent_devpkg_debian="libevent-dev"
690 dnl On Gnu/Linux or any place we require it, we'll add librt to the Libevent
691 dnl linking for static builds.
692 STATIC_LIBEVENT_FLAGS=""
693 if test "$enable_static_libevent" = "yes"; then
694 if test "$have_rt" = "yes"; then
695 STATIC_LIBEVENT_FLAGS=" -lrt "
699 TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32], [
701 #include <winsock2.h>
703 #include <sys/time.h>
704 #include <sys/types.h>
705 #include <event2/event.h>], [
707 #include <winsock2.h>
710 struct event_base *event_base_new(void);
711 void event_base_free(struct event_base *);],
714 {WSADATA d; WSAStartup(0x101,&d); }
716 event_base_free(event_base_new());
717 ], [--with-libevent-dir], [/opt/libevent])
719 dnl Determine the incantation needed to link libevent.
721 save_LDFLAGS="$LDFLAGS"
722 save_CPPFLAGS="$CPPFLAGS"
724 LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
725 LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
726 CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
728 AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
730 if test "$enable_static_libevent" = "yes"; then
731 if test "$tor_cv_library_libevent_dir" = "(system)"; then
732 AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
734 TOR_LIBEVENT_LIBS="$TOR_LIBDIR_libevent/libevent.a $STATIC_LIBEVENT_FLAGS"
737 if test "x$ac_cv_header_event2_event_h" = "xyes"; then
738 AC_SEARCH_LIBS(event_new, [event event_core], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for event_new"))
739 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"))
741 if test "$ac_cv_search_event_new" != "none required"; then
742 TOR_LIBEVENT_LIBS="$ac_cv_search_event_new"
744 if test "$ac_cv_search_evdns_base_new" != "none required"; then
745 TOR_LIBEVENT_LIBS="$ac_cv_search_evdns_base_new $TOR_LIBEVENT_LIBS"
748 AC_MSG_ERROR("libevent2 is required but the headers could not be found")
752 dnl Now check for particular libevent functions.
753 AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file \
754 evutil_secure_rng_add_bytes \
758 LDFLAGS="$save_LDFLAGS"
759 CPPFLAGS="$save_CPPFLAGS"
761 dnl Check that libevent is at least at version 2.0.10, the first stable
762 dnl release of its series
763 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
764 AC_MSG_CHECKING([whether Libevent is new enough])
765 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
766 #include <event2/event.h>
767 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
773 ])], [ AC_MSG_RESULT([yes]) ],
774 [ AC_MSG_RESULT([no])
775 AC_MSG_ERROR([Libevent is not new enough. We require 2.0.10-stable or later]) ] )
778 LDFLAGS="$save_LDFLAGS"
779 CPPFLAGS="$save_CPPFLAGS"
781 AC_SUBST(TOR_LIBEVENT_LIBS)
783 dnl ------------------------------------------------------
784 dnl Where do you live, libm?
786 dnl On some platforms (Haiku/BeOS) the math library is
787 dnl part of libroot. In which case don't link against lm
790 AC_SEARCH_LIBS(pow, [m], , AC_MSG_ERROR([Could not find pow in libm or libc.]))
791 if test "$ac_cv_search_pow" != "none required"; then
792 TOR_LIB_MATH="$ac_cv_search_pow"
795 AC_SUBST(TOR_LIB_MATH)
797 dnl ------------------------------------------------------
798 dnl Where do you live, openssl? And how do we call you?
800 tor_openssl_pkg_redhat="openssl"
801 tor_openssl_pkg_debian="libssl-dev"
802 tor_openssl_devpkg_redhat="openssl-devel"
803 tor_openssl_devpkg_debian="libssl-dev"
805 ALT_openssl_WITHVAL=""
807 AS_HELP_STRING(--with-ssl-dir=PATH, [obsolete alias for --with-openssl-dir]),
809 if test "x$withval" != "xno" && test "x$withval" != "x"; then
810 ALT_openssl_WITHVAL="$withval"
814 AC_MSG_NOTICE([Now, we'll look for OpenSSL >= 1.0.1])
815 TOR_SEARCH_LIBRARY(openssl, $tryssldir, [-lssl -lcrypto $TOR_LIB_GDI $TOR_LIB_WS32],
816 [#include <openssl/ssl.h>
817 char *getenv(const char *);],
818 [struct ssl_cipher_st;
819 unsigned SSL_CIPHER_get_id(const struct ssl_cipher_st *);
820 char *getenv(const char *);],
821 dnl This funny-looking test program calls getenv, so that the compiler
822 dnl will neither make code that call SSL_CIPHER_get_id(NULL) [producing
823 dnl a crash], nor optimize out the call to SSL_CIPHER_get_id().
824 dnl We look for SSL_cipher_get_id() because it is present in
825 dnl OpenSSL >=1.0.1, because it is not deprecated, and because Tor
827 [if (getenv("THIS_SHOULDNT_BE_SET_X201803")) SSL_CIPHER_get_id((void *)0);], [],
828 [/usr/local/opt/openssl /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /opt/openssl])
830 dnl XXXX check for OPENSSL_VERSION_NUMBER == SSLeay()
832 if test "$enable_static_openssl" = "yes"; then
833 if test "$tor_cv_library_openssl_dir" = "(system)"; then
834 AC_MSG_ERROR("You must specify an explicit --with-openssl-dir=x option when using --enable-static-openssl")
836 TOR_OPENSSL_LIBS="$TOR_LIBDIR_openssl/libssl.a $TOR_LIBDIR_openssl/libcrypto.a"
839 TOR_OPENSSL_LIBS="-lssl -lcrypto"
841 AC_SUBST(TOR_OPENSSL_LIBS)
843 dnl Now check for particular openssl functions.
845 save_LDFLAGS="$LDFLAGS"
846 save_CPPFLAGS="$CPPFLAGS"
847 LIBS="$TOR_OPENSSL_LIBS $LIBS"
848 LDFLAGS="$TOR_LDFLAGS_openssl $LDFLAGS"
849 CPPFLAGS="$TOR_CPPFLAGS_openssl $CPPFLAGS"
851 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
852 #include <openssl/opensslv.h>
853 #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x1000100fL
858 [ 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.]) ])
860 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
861 #include <openssl/opensslv.h>
862 #include <openssl/evp.h>
863 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_ECDSA)
866 #if !defined(NID_X9_62_prime256v1) || !defined(NID_secp224r1)
867 #error "curves unavailable"
871 [ 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.]) ])
873 AC_CHECK_MEMBERS([struct ssl_method_st.get_cipher_by_char], , ,
874 [#include <openssl/ssl.h>
878 SSL_SESSION_get_master_key \
879 SSL_get_server_random \
880 SSL_get_client_ciphers \
881 SSL_get_client_random \
886 dnl Check if OpenSSL has scrypt implementation.
887 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
889 dnl Check if OpenSSL structures are opaque
890 AC_CHECK_MEMBERS([SSL.state], , ,
891 [#include <openssl/ssl.h>
894 AC_CHECK_SIZEOF(SHA_CTX, , [AC_INCLUDES_DEFAULT()
895 #include <openssl/sha.h>
898 dnl Define the set of checks for KIST scheduler support.
899 AC_DEFUN([CHECK_KIST_SUPPORT],[
900 dnl KIST needs struct tcp_info and for certain members to exist.
902 [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
903 , ,[[#include <netinet/tcp.h>]])
904 dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
905 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
906 #include <linux/sockios.h>
910 ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
911 if test "x$have_siocoutqnsd" = "xyes"; then
912 if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
913 if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
914 have_kist_support=yes
919 dnl Now, trigger the check.
921 AS_IF([test "x$have_kist_support" = "xyes"],
922 [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
924 [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
927 LDFLAGS="$save_LDFLAGS"
928 CPPFLAGS="$save_CPPFLAGS"
930 dnl ------------------------------------------------------
931 dnl Where do you live, zlib? And how do we call you?
933 tor_zlib_pkg_redhat="zlib"
934 tor_zlib_pkg_debian="zlib1g"
935 tor_zlib_devpkg_redhat="zlib-devel"
936 tor_zlib_devpkg_debian="zlib1g-dev"
938 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
940 [const char * zlibVersion(void);],
941 [zlibVersion();], [--with-zlib-dir],
944 if test "$enable_static_zlib" = "yes"; then
945 if test "$tor_cv_library_zlib_dir" = "(system)"; then
946 AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
947 using --enable-static-zlib")
949 TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
954 AC_SUBST(TOR_ZLIB_LIBS)
956 dnl ------------------------------------------------------
957 dnl Where we do we find lzma?
960 AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
961 [case "${enableval}" in
964 * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
967 if test "x$enable_lzma" = "xno"; then
970 PKG_CHECK_MODULES([LZMA],
975 if test "x$have_lzma" = "xno" ; then
976 AC_MSG_WARN([Unable to find liblzma.])
980 if test "x$have_lzma" = "xyes"; then
981 AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
982 TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
983 TOR_LZMA_LIBS="${LZMA_LIBS}"
985 AC_SUBST(TOR_LZMA_CFLAGS)
986 AC_SUBST(TOR_LZMA_LIBS)
988 dnl ------------------------------------------------------
989 dnl Where we do we find zstd?
992 AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
993 [case "${enableval}" in
996 * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
999 if test "x$enable_zstd" = "xno"; then
1002 PKG_CHECK_MODULES([ZSTD],
1007 if test "x$have_zstd" = "xno" ; then
1008 AC_MSG_WARN([Unable to find libzstd.])
1012 if test "x$have_zstd" = "xyes"; then
1013 AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
1014 TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
1015 TOR_ZSTD_LIBS="${ZSTD_LIBS}"
1017 dnl now check for zstd functions
1019 save_CFLAGS="$CFLAGS"
1020 LIBS="$LIBS $ZSTD_LIBS"
1021 CFLAGS="$CFLAGS $ZSTD_CFLAGS"
1022 AC_CHECK_FUNCS(ZSTD_estimateCStreamSize \
1023 ZSTD_estimateDCtxSize)
1025 CFLAGS="$save_CFLAGS"
1027 AC_SUBST(TOR_ZSTD_CFLAGS)
1028 AC_SUBST(TOR_ZSTD_LIBS)
1030 dnl ----------------------------------------------------------------------
1031 dnl Check if libcap is available for capabilities.
1033 tor_cap_pkg_debian="libcap2"
1034 tor_cap_pkg_redhat="libcap"
1035 tor_cap_devpkg_debian="libcap-dev"
1036 tor_cap_devpkg_redhat="libcap-devel"
1038 AC_CHECK_LIB([cap], [cap_init], [],
1039 AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
1041 AC_CHECK_FUNCS(cap_set_proc)
1043 dnl ---------------------------------------------------------------------
1044 dnl Now that we know about our major libraries, we can check for compiler
1045 dnl and linker hardening options. We need to do this with the libraries known,
1046 dnl since sometimes the linker will like an option but not be willing to
1047 dnl use it with a build of a library.
1049 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
1050 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"
1058 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1059 #if !defined(__clang__)
1061 #endif])], have_clang=yes, have_clang=no)
1063 if test "x$enable_gcc_hardening" != "xno"; then
1064 CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
1065 if test "x$have_clang" = "xyes"; then
1066 TOR_CHECK_CFLAGS(-Qunused-arguments)
1068 TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
1069 AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
1070 AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1071 m4_ifdef([AS_VAR_IF],[
1072 AS_VAR_IF(can_compile, [yes],
1073 AS_VAR_IF(can_link, [yes],
1075 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.)]))
1077 AS_VAR_POPDEF([can_link])
1078 AS_VAR_POPDEF([can_compile])
1079 TOR_CHECK_CFLAGS(-Wstack-protector)
1080 TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1081 if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1082 TOR_CHECK_CFLAGS(-fPIE)
1083 TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1085 TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1088 if test "$fragile_hardening" = "yes"; then
1089 TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1090 if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1091 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.])
1094 if test "$tor_cv_cflags__ftrapv" != "yes"; then
1095 AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1098 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1099 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1100 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*])
1103 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1104 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1105 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*])
1108 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1111 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1112 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1114 mulodi_fixes_ftrapv=no
1115 if test "$have_clang" = "yes"; then
1116 saved_CFLAGS="$CFLAGS"
1117 CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1118 AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1123 int main(int argc, char **argv)
1125 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1126 * (int64_t)atoi(argv[3]);
1129 [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1130 [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1131 if test "$ftrapv_can_link" = "no"; then
1132 AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1137 int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1141 int main(int argc, char **argv)
1143 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1144 * (int64_t)atoi(argv[3]);
1147 [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1148 [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1150 CFLAGS="$saved_CFLAGS"
1153 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1155 dnl These cflags add bunches of branches, and we haven't been able to
1156 dnl persuade ourselves that they're suitable for code that needs to be
1158 AC_SUBST(CFLAGS_BUGTRAP)
1159 dnl These cflags are variant ones sutable for code that needs to be
1161 AC_SUBST(CFLAGS_CONSTTIME)
1163 if test "x$enable_linker_hardening" != "xno"; then
1164 TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1167 # For backtrace support
1168 TOR_CHECK_LDFLAGS(-rdynamic)
1170 dnl ------------------------------------------------------
1171 dnl Now see if we have a -fomit-frame-pointer compiler option.
1173 saved_CFLAGS="$CFLAGS"
1174 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1175 F_OMIT_FRAME_POINTER=''
1176 if test "$saved_CFLAGS" != "$CFLAGS"; then
1177 if test "$fragile_hardening" = "yes"; then
1178 F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1181 CFLAGS="$saved_CFLAGS"
1182 AC_SUBST(F_OMIT_FRAME_POINTER)
1184 dnl ------------------------------------------------------
1185 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1186 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1187 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1189 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1191 dnl ============================================================
1192 dnl Check for libseccomp
1194 if test "x$enable_seccomp" != "xno"; then
1195 AC_CHECK_HEADERS([seccomp.h])
1196 AC_SEARCH_LIBS(seccomp_init, [seccomp])
1199 dnl ============================================================
1200 dnl Check for libscrypt
1202 if test "x$enable_libscrypt" != "xno"; then
1203 AC_CHECK_HEADERS([libscrypt.h])
1204 AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1205 AC_CHECK_FUNCS([libscrypt_scrypt])
1208 dnl ============================================================
1209 dnl We need an implementation of curve25519.
1211 dnl set these defaults.
1212 build_curve25519_donna=no
1213 build_curve25519_donna_c64=no
1214 use_curve25519_donna=no
1215 use_curve25519_nacl=no
1218 dnl The best choice is using curve25519-donna-c64, but that requires
1220 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1221 tor_cv_can_use_curve25519_donna_c64,
1223 [AC_LANG_PROGRAM([dnl
1225 typedef unsigned uint128_t __attribute__((mode(TI)));
1226 int func(uint64_t a, uint64_t b) {
1227 uint128_t c = ((uint128_t)a) * b;
1228 int ok = ((uint64_t)(c>>96)) == 522859 &&
1229 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1230 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1231 (((uint64_t)(c))&0xffffffffL) == 0;
1235 int ok = func( ((uint64_t)2000000000) * 1000000000,
1236 ((uint64_t)1234567890) << 24);
1239 [tor_cv_can_use_curve25519_donna_c64=yes],
1240 [tor_cv_can_use_curve25519_donna_c64=no],
1242 [AC_LANG_PROGRAM([dnl
1244 typedef unsigned uint128_t __attribute__((mode(TI)));
1245 int func(uint64_t a, uint64_t b) {
1246 uint128_t c = ((uint128_t)a) * b;
1247 int ok = ((uint64_t)(c>>96)) == 522859 &&
1248 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1249 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1250 (((uint64_t)(c))&0xffffffffL) == 0;
1254 int ok = func( ((uint64_t)2000000000) * 1000000000,
1255 ((uint64_t)1234567890) << 24);
1258 [tor_cv_can_use_curve25519_donna_c64=cross],
1259 [tor_cv_can_use_curve25519_donna_c64=no])])])
1261 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1262 nacl/crypto_scalarmult_curve25519.h])
1264 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1265 tor_cv_can_use_curve25519_nacl,
1266 [tor_saved_LIBS="$LIBS"
1269 [AC_LANG_PROGRAM([dnl
1270 #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1271 #include <crypto_scalarmult_curve25519.h>
1272 #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1273 #include <nacl/crypto_scalarmult_curve25519.h>
1275 #ifdef crypto_scalarmult_curve25519_ref_BYTES
1276 #error Hey, this is the reference implementation! That's not fast.
1279 unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1280 ])], [tor_cv_can_use_curve25519_nacl=yes],
1281 [tor_cv_can_use_curve25519_nacl=no])
1282 LIBS="$tor_saved_LIBS" ])
1284 dnl Okay, now we need to figure out which one to actually use. Fall back
1285 dnl to curve25519-donna.c
1287 if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1288 build_curve25519_donna_c64=yes
1289 use_curve25519_donna=yes
1290 elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1291 use_curve25519_nacl=yes
1292 CURVE25519_LIBS=-lnacl
1294 build_curve25519_donna=yes
1295 use_curve25519_donna=yes
1298 if test "x$use_curve25519_donna" = "xyes"; then
1299 AC_DEFINE(USE_CURVE25519_DONNA, 1,
1300 [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1302 if test "x$use_curve25519_nacl" = "xyes"; then
1303 AC_DEFINE(USE_CURVE25519_NACL, 1,
1304 [Defined if we should use a curve25519 from nacl])
1306 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1307 test "x$build_curve25519_donna" = "xyes")
1308 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1309 test "x$build_curve25519_donna_c64" = "xyes")
1310 AC_SUBST(CURVE25519_LIBS)
1312 dnl Make sure to enable support for large off_t if available.
1315 AC_CHECK_HEADERS([assert.h \
1330 gnu/libc-version.h \
1370 AC_CHECK_HEADERS(sys/param.h)
1372 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1373 [#ifdef HAVE_SYS_TYPES_H
1374 #include <sys/types.h>
1376 #ifdef HAVE_SYS_SOCKET_H
1377 #include <sys/socket.h>
1379 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1380 [#ifdef HAVE_SYS_TYPES_H
1381 #include <sys/types.h>
1383 #ifdef HAVE_SYS_SOCKET_H
1384 #include <sys/socket.h>
1386 #ifdef HAVE_NET_IF_H
1389 #ifdef HAVE_NETINET_IN_H
1390 #include <netinet/in.h>
1393 AC_CHECK_HEADERS(linux/if.h,[],[],
1395 #ifdef HAVE_SYS_SOCKET_H
1396 #include <sys/socket.h>
1400 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1401 linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1402 [#ifdef HAVE_SYS_TYPES_H
1403 #include <sys/types.h>
1405 #ifdef HAVE_SYS_SOCKET_H
1406 #include <sys/socket.h>
1408 #ifdef HAVE_LIMITS_H
1411 #ifdef HAVE_LINUX_TYPES_H
1412 #include <linux/types.h>
1414 #ifdef HAVE_NETINET_IN6_H
1415 #include <netinet/in6.h>
1417 #ifdef HAVE_NETINET_IN_H
1418 #include <netinet/in.h>
1421 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1422 linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1423 [#ifdef HAVE_SYS_TYPES_H
1424 #include <sys/types.h>
1426 #ifdef HAVE_SYS_SOCKET_H
1427 #include <sys/socket.h>
1429 #ifdef HAVE_LIMITS_H
1432 #ifdef HAVE_LINUX_TYPES_H
1433 #include <linux/types.h>
1435 #ifdef HAVE_NETINET_IN6_H
1436 #include <netinet/in6.h>
1438 #ifdef HAVE_NETINET_IN_H
1439 #include <netinet/in.h>
1441 #ifdef HAVE_LINUX_IF_H
1442 #include <linux/if.h>
1446 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1449 if test "x$linux_netfilter_ipv4" = "x1"; then
1452 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1455 if test "x$transparent_ok" = "x1"; then
1456 AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1458 AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1461 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1462 [#ifdef HAVE_SYS_TYPES_H
1463 #include <sys/types.h>
1465 #ifdef HAVE_SYS_TIME_H
1466 #include <sys/time.h>
1469 dnl In case we aren't given a working stdint.h, we'll need to grow our own.
1472 AC_CHECK_SIZEOF(int8_t)
1473 AC_CHECK_SIZEOF(int16_t)
1474 AC_CHECK_SIZEOF(int32_t)
1475 AC_CHECK_SIZEOF(int64_t)
1476 AC_CHECK_SIZEOF(uint8_t)
1477 AC_CHECK_SIZEOF(uint16_t)
1478 AC_CHECK_SIZEOF(uint32_t)
1479 AC_CHECK_SIZEOF(uint64_t)
1480 AC_CHECK_SIZEOF(intptr_t)
1481 AC_CHECK_SIZEOF(uintptr_t)
1483 dnl AC_CHECK_TYPES([int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, intptr_t, uintptr_t])
1485 AC_CHECK_SIZEOF(char)
1486 AC_CHECK_SIZEOF(short)
1487 AC_CHECK_SIZEOF(int)
1488 AC_CHECK_SIZEOF(long)
1489 AC_CHECK_SIZEOF(long long)
1490 AC_CHECK_SIZEOF(__int64)
1491 AC_CHECK_SIZEOF(void *)
1492 AC_CHECK_SIZEOF(time_t)
1493 AC_CHECK_SIZEOF(size_t)
1494 AC_CHECK_SIZEOF(pid_t)
1496 AC_CHECK_TYPES([uint, u_char, ssize_t])
1498 AC_PC_FROM_UCONTEXT([:])
1500 dnl used to include sockaddr_storage, but everybody has that.
1501 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1502 [#ifdef HAVE_SYS_TYPES_H
1503 #include <sys/types.h>
1505 #ifdef HAVE_NETINET_IN_H
1506 #include <netinet/in.h>
1508 #ifdef HAVE_NETINET_IN6_H
1509 #include <netinet/in6.h>
1511 #ifdef HAVE_SYS_SOCKET_H
1512 #include <sys/socket.h>
1515 #define _WIN32_WINNT 0x0501
1516 #define WIN32_LEAN_AND_MEAN
1517 #include <winsock2.h>
1518 #include <ws2tcpip.h>
1521 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1522 [#ifdef HAVE_SYS_TYPES_H
1523 #include <sys/types.h>
1525 #ifdef HAVE_NETINET_IN_H
1526 #include <netinet/in.h>
1528 #ifdef HAVE_NETINET_IN6_H
1529 #include <netinet/in6.h>
1531 #ifdef HAVE_SYS_SOCKET_H
1532 #include <sys/socket.h>
1535 #define _WIN32_WINNT 0x0501
1536 #define WIN32_LEAN_AND_MEAN
1537 #include <winsock2.h>
1538 #include <ws2tcpip.h>
1542 AC_CHECK_TYPES([rlim_t], , ,
1543 [#ifdef HAVE_SYS_TYPES_H
1544 #include <sys/types.h>
1546 #ifdef HAVE_SYS_TIME_H
1547 #include <sys/time.h>
1549 #ifdef HAVE_SYS_RESOURCE_H
1550 #include <sys/resource.h>
1554 AX_CHECK_SIGN([time_t],
1557 #ifdef HAVE_SYS_TYPES_H
1558 #include <sys/types.h>
1560 #ifdef HAVE_SYS_TIME_H
1561 #include <sys/time.h>
1568 if test "$ax_cv_decl_time_t_signed" = "no"; then
1569 AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1572 AX_CHECK_SIGN([size_t],
1573 [ tor_cv_size_t_signed=yes ],
1574 [ tor_cv_size_t_signed=no ], [
1575 #ifdef HAVE_SYS_TYPES_H
1576 #include <sys/types.h>
1580 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1581 AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1584 AX_CHECK_SIGN([enum always],
1585 [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1587 enum always { AAA, BBB, CCC };
1590 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1591 #ifdef HAVE_SYS_SOCKET_H
1592 #include <sys/socket.h>
1596 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1598 AC_CHECK_SIZEOF(cell_t)
1600 # Now make sure that NULL can be represented as zero bytes.
1601 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1602 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1603 [[#include <stdlib.h>
1606 #ifdef HAVE_STDDEF_H
1609 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1610 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1611 [tor_cv_null_is_zero=yes],
1612 [tor_cv_null_is_zero=no],
1613 [tor_cv_null_is_zero=cross])])
1615 if test "$tor_cv_null_is_zero" = "cross"; then
1616 # Cross-compiling; let's hope that the target isn't raving mad.
1617 AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1620 if test "$tor_cv_null_is_zero" != "no"; then
1621 AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1622 [Define to 1 iff memset(0) sets pointers to NULL])
1625 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1626 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1627 [[#include <stdlib.h>
1630 #ifdef HAVE_STDDEF_H
1633 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1634 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1635 [tor_cv_dbl0_is_zero=yes],
1636 [tor_cv_dbl0_is_zero=no],
1637 [tor_cv_dbl0_is_zero=cross])])
1639 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1640 # Cross-compiling; let's hope that the target isn't raving mad.
1641 AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1644 if test "$tor_cv_dbl0_is_zero" != "no"; then
1645 AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1646 [Define to 1 iff memset(0) sets doubles to 0.0])
1649 # And what happens when we malloc zero?
1650 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1651 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1652 [[#include <stdlib.h>
1655 #ifdef HAVE_STDDEF_H
1658 int main () { return malloc(0)?0:1; }]])],
1659 [tor_cv_malloc_zero_works=yes],
1660 [tor_cv_malloc_zero_works=no],
1661 [tor_cv_malloc_zero_works=cross])])
1663 if test "$tor_cv_malloc_zero_works" = "cross"; then
1664 # Cross-compiling; let's hope that the target isn't raving mad.
1665 AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1668 if test "$tor_cv_malloc_zero_works" = "yes"; then
1669 AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1670 [Define to 1 iff malloc(0) returns a pointer])
1673 # whether we seem to be in a 2s-complement world.
1674 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1675 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1676 [[int main () { int problem = ((-99) != (~99)+1);
1677 return problem ? 1 : 0; }]])],
1678 [tor_cv_twos_complement=yes],
1679 [tor_cv_twos_complement=no],
1680 [tor_cv_twos_complement=cross])])
1682 if test "$tor_cv_twos_complement" = "cross"; then
1683 # Cross-compiling; let's hope that the target isn't raving mad.
1684 AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1687 if test "$tor_cv_twos_complement" != "no"; then
1688 AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1689 [Define to 1 iff we represent negative integers with
1693 # What does shifting a negative value do?
1694 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1695 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1696 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1697 [tor_cv_sign_extend=yes],
1698 [tor_cv_sign_extend=no],
1699 [tor_cv_sign_extend=cross])])
1701 if test "$tor_cv_sign_extend" = "cross"; then
1702 # Cross-compiling; let's hope that the target isn't raving mad.
1703 AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1706 if test "$tor_cv_sign_extend" != "no"; then
1707 AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1708 [Define to 1 iff right-shifting a negative value performs sign-extension])
1711 # Is uint8_t the same type as unsigned char?
1712 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1713 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1716 unsigned char c;]])],
1717 [tor_cv_uint8_uchar=yes],
1718 [tor_cv_uint8_uchar=no],
1719 [tor_cv_uint8_uchar=cross])])
1721 if test "$tor_cv_uint8_uchar" = "cross"; then
1722 AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1725 if test "$tor_cv_uint8_uchar" = "no"; then
1726 AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1729 # Whether we should use the dmalloc memory allocation debugging library.
1730 AC_MSG_CHECKING(whether to use dmalloc (debug memory allocation library))
1731 AC_ARG_WITH(dmalloc,
1732 AS_HELP_STRING(--with-dmalloc, [use debug memory allocation library]),
1733 [if [[ "$withval" = "yes" ]]; then
1739 fi], [ dmalloc=0; AC_MSG_RESULT(no) ]
1742 if [[ $dmalloc -eq 1 ]]; then
1743 AC_CHECK_HEADERS(dmalloc.h, , AC_MSG_ERROR(dmalloc header file not found. Do you have the development files for dmalloc installed?))
1744 AC_SEARCH_LIBS(dmalloc_malloc, [dmallocth dmalloc], , AC_MSG_ERROR(Libdmalloc library not found. If you enable it you better have it installed.))
1745 AC_DEFINE(USE_DMALLOC, 1, [Debug memory allocation library])
1746 AC_CHECK_FUNCS(dmalloc_strdup dmalloc_strndup)
1749 AC_ARG_WITH(tcmalloc,
1750 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library]),
1751 [ tcmalloc=yes ], [ tcmalloc=no ])
1753 if test "x$tcmalloc" = "xyes"; then
1754 LDFLAGS="-ltcmalloc $LDFLAGS"
1757 using_custom_malloc=no
1758 if test "x$enable_openbsd_malloc" = "xyes"; then
1759 using_custom_malloc=yes
1761 if test "x$tcmalloc" = "xyes"; then
1762 using_custom_malloc=yes
1764 if test "$using_custom_malloc" = "no"; then
1765 AC_CHECK_FUNCS(mallinfo)
1768 # By default, we're going to assume we don't have mlockall()
1769 # bionic and other platforms have various broken mlockall subsystems.
1770 # Some systems don't have a working mlockall, some aren't linkable,
1771 # and some have it but don't declare it.
1772 AC_CHECK_FUNCS(mlockall)
1773 AC_CHECK_DECLS([mlockall], , , [
1774 #ifdef HAVE_SYS_MMAN_H
1775 #include <sys/mman.h>
1778 # Allow user to specify an alternate syslog facility
1779 AC_ARG_WITH(syslog-facility,
1780 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1781 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1782 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1783 AC_SUBST(LOGFACILITY)
1785 # Check if we have getresuid and getresgid
1786 AC_CHECK_FUNCS(getresuid getresgid)
1788 # Check for gethostbyname_r in all its glorious incompatible versions.
1789 # (This logic is based on that in Python's configure.in)
1790 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1791 [Define this if you have any gethostbyname_r()])
1793 AC_CHECK_FUNC(gethostbyname_r, [
1794 AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1796 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1797 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1801 struct hostent *h1, *h2;
1803 (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1805 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1806 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1807 [Define this if gethostbyname_r takes 6 arguments])
1810 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1816 (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1818 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1819 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1820 [Define this if gethostbyname_r takes 5 arguments])
1823 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1828 struct hostent_data hd;
1829 (void) gethostbyname_r(cp1,h1,&hd);
1831 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1832 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1833 [Define this if gethostbyname_r takes 3 arguments])
1843 AC_CACHE_CHECK([whether the C compiler supports __func__],
1844 tor_cv_have_func_macro,
1845 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1847 int main(int c, char **v) { puts(__func__); }])],
1848 tor_cv_have_func_macro=yes,
1849 tor_cv_have_func_macro=no))
1851 AC_CACHE_CHECK([whether the C compiler supports __FUNC__],
1852 tor_cv_have_FUNC_macro,
1853 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1855 int main(int c, char **v) { puts(__FUNC__); }])],
1856 tor_cv_have_FUNC_macro=yes,
1857 tor_cv_have_FUNC_macro=no))
1859 AC_CACHE_CHECK([whether the C compiler supports __FUNCTION__],
1860 tor_cv_have_FUNCTION_macro,
1861 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1863 int main(int c, char **v) { puts(__FUNCTION__); }])],
1864 tor_cv_have_FUNCTION_macro=yes,
1865 tor_cv_have_FUNCTION_macro=no))
1867 AC_CACHE_CHECK([whether we have extern char **environ already declared],
1868 tor_cv_have_environ_declared,
1869 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1870 #ifdef HAVE_UNISTD_H
1874 int main(int c, char **v) { char **t = environ; }])],
1875 tor_cv_have_environ_declared=yes,
1876 tor_cv_have_environ_declared=no))
1878 if test "$tor_cv_have_func_macro" = "yes"; then
1879 AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
1882 if test "$tor_cv_have_FUNC_macro" = "yes"; then
1883 AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
1886 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
1887 AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
1888 [Defined if the compiler supports __FUNCTION__])
1891 if test "$tor_cv_have_environ_declared" = "yes"; then
1892 AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
1893 [Defined if we have extern char **environ already declared])
1896 # $prefix stores the value of the --prefix command line option, or
1897 # NONE if the option wasn't set. In the case that it wasn't set, make
1898 # it be the default, so that we can use it to expand directories now.
1899 if test "x$prefix" = "xNONE"; then
1900 prefix=$ac_default_prefix
1903 # and similarly for $exec_prefix
1904 if test "x$exec_prefix" = "xNONE"; then
1908 if test "x$BUILDDIR" = "x"; then
1912 AH_TEMPLATE([BUILDDIR],[tor's build directory])
1913 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
1915 if test "x$SRCDIR" = "x"; then
1916 SRCDIR=$(cd "$srcdir"; pwd)
1918 AH_TEMPLATE([SRCDIR],[tor's sourcedir directory])
1919 AC_DEFINE_UNQUOTED(SRCDIR,"$SRCDIR")
1921 if test "x$CONFDIR" = "x"; then
1922 CONFDIR=`eval echo $sysconfdir/tor`
1925 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
1926 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
1928 BINDIR=`eval echo $bindir`
1930 LOCALSTATEDIR=`eval echo $localstatedir`
1931 AC_SUBST(LOCALSTATEDIR)
1933 if test "$bwin32" = "true"; then
1934 # Test if the linker supports the --nxcompat and --dynamicbase options
1936 save_LDFLAGS="$LDFLAGS"
1937 LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
1938 AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
1939 AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
1940 [AC_MSG_RESULT([yes])]
1941 [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
1942 [AC_MSG_RESULT([no])]
1944 LDFLAGS="$save_LDFLAGS"
1947 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
1948 # than autoconf's macros like.
1949 if test "$GCC" = "yes"; then
1950 # Disable GCC's strict aliasing checks. They are an hours-to-debug
1951 # accident waiting to happen.
1952 CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
1954 # Override optimization level for non-gcc compilers
1956 enable_gcc_warnings=no
1957 enable_gcc_warnings_advisory=no
1960 # Warnings implies advisory-warnings and -Werror.
1961 if test "$enable_gcc_warnings" = "yes"; then
1962 enable_gcc_warnings_advisory=yes
1963 enable_fatal_warnings=yes
1966 # OS X Lion started deprecating the system openssl. Let's just disable
1967 # all deprecation warnings on OS X. Also, to potentially make the binary
1968 # a little smaller, let's enable dead_strip.
1972 CFLAGS="$CFLAGS -Wno-deprecated-declarations"
1973 LDFLAGS="$LDFLAGS -dead_strip" ;;
1976 # Add some more warnings which we use in development but not in the
1977 # released versions. (Some relevant gcc versions can't handle these.)
1979 # Note that we have to do this near the end of the autoconf process, or
1980 # else we may run into problems when these warnings hit on the testing C
1981 # programs that autoconf wants to build.
1982 if test "x$enable_gcc_warnings_advisory" != "xno"; then
1985 *-*-openbsd* | *-*-bitrig*)
1986 # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
1987 # That's fine, except that the headers don't pass -Wredundant-decls.
1988 # Therefore, let's disable -Wsystem-headers when we're building
1989 # with maximal warnings on OpenBSD.
1990 CFLAGS="$CFLAGS -Wno-system-headers" ;;
1993 # GCC4.3 users once report trouble with -Wstrict-overflow=5. GCC5 users
1994 # have it work better.
1995 # CFLAGS="$CFLAGS -Wstrict-overflow=1"
1997 # This warning was added in gcc 4.3, but it appears to generate
1998 # spurious warnings in gcc 4.4. I don't know if it works in 4.5.
1999 #CFLAGS="$CFLAGS -Wlogical-op"
2001 m4_foreach_w([warning_flag], [
2003 -Waddress-of-array-temporary
2004 -Waddress-of-temporary
2006 -Wanonymous-pack-parens
2009 -Warc-bridge-casts-disallowed-in-nonarc
2010 -Warc-maybe-repeated-use-of-weak
2011 -Warc-performSelector-leaks
2012 -Warc-repeated-use-of-weak
2014 -Warray-bounds-pointer-arithmetic
2016 -Wasm-operand-widths
2018 -Watomic-property-with-user-defined-accessor
2020 -Wauto-storage-class
2023 -Wbackslash-newline-escape
2024 -Wbad-array-new-length
2025 -Wbind-to-temporary-copy
2026 -Wbitfield-constant-conversion
2029 -Wbuiltin-requires-header
2031 -Wcompare-distinct-pointer-types
2032 -Wcomplex-component-init
2033 -Wconditional-type-mismatch
2035 -Wconstant-conversion
2036 -Wconstant-logical-operand
2037 -Wconstexpr-not-const
2038 -Wcustom-atomic-properties
2040 -Wdangling-initializer-list
2042 -Wdelegating-ctor-cycles
2043 -Wdeprecated-implementations
2044 -Wdeprecated-register
2045 -Wdirect-ivar-access
2047 -Wdistributed-object-modifiers
2049 -Wdollar-in-identifier-extension
2051 -Wduplicate-decl-specifier
2053 -Wduplicate-method-arg
2054 -Wduplicate-method-match
2056 -Wdynamic-class-memaccess
2057 -Wembedded-directive
2058 -Wempty-translation-unit
2060 -Wexit-time-destructors
2061 -Wexplicit-ownership-type
2062 -Wextern-initializer
2066 -Wflexible-array-extensions
2069 -Wfour-char-constants
2071 -Wglobal-constructors
2072 -Wgnu-array-member-paren-init
2074 -Wgnu-static-float-init
2077 -Widiomatic-parentheses
2078 -Wignored-attributes
2079 -Wimplicit-atomic-properties
2080 -Wimplicit-conversion-floating-point-to-bool
2081 -Wimplicit-exception-spec-mismatch
2082 -Wimplicit-fallthrough
2083 -Wimplicit-fallthrough-per-function
2084 -Wimplicit-retain-self
2085 -Wimport-preprocessor-directive-pedantic
2086 -Wincompatible-library-redeclaration
2087 -Wincompatible-pointer-types-discards-qualifiers
2088 -Wincomplete-implementation
2090 -Wincomplete-umbrella
2093 -Wint-to-void-pointer-cast
2099 -Winvalid-source-encoding
2100 -Winvalid-token-paste
2101 -Wknr-promoted-parameter
2102 -Wlarge-by-value-copy
2103 -Wliteral-conversion
2105 -Wlocal-type-template-args
2109 -Wmalformed-warning-check
2113 -Wmismatched-parameter-types
2114 -Wmismatched-return-types
2115 -Wmissing-field-initializers
2116 -Wmissing-format-attribute
2118 -Wmissing-selector-name
2120 -Wmissing-variable-declarations
2124 -Wnon-literal-null-conversion
2126 -Wnonportable-cfstrings
2132 -Wout-of-line-declaration
2134 -Woverlength-strings
2136 -Woverriding-method-mismatch
2137 -Wpointer-type-mismatch
2138 -Wpredefined-identifier-outside-function
2139 -Wprotocol-property-synthesis-ambiguity
2140 -Wreadonly-iboutlet-property
2141 -Wreadonly-setter-attrs
2143 -Wreceiver-forward-class
2145 -Wreinterpret-base-class
2146 -Wrequires-super-attribute
2147 -Wreserved-user-defined-literal
2148 -Wreturn-stack-address
2150 -Wselector-type-mismatch
2152 -Wserialized-diagnostics
2154 -Wshift-count-negative
2155 -Wshift-count-overflow
2156 -Wshift-negative-value
2158 -Wshift-sign-overflow
2160 -Wsizeof-array-argument
2161 -Wsource-uses-openmp
2164 -Wstatic-local-in-inline
2168 -Wstrlcpy-strlcat-size
2170 -Wsuggest-attribute=format
2171 -Wsuggest-attribute=noreturn
2172 -Wsuper-class-method-mismatch
2175 -Wtautological-constant-out-of-range-compare
2176 -Wtentative-definition-incomplete-type
2179 -Wtypedef-redefinition
2182 -Wundefined-internal
2183 -Wundefined-reinterpret-cast
2185 -Wunicode-whitespace
2186 -Wunknown-warning-option
2187 -Wunnamed-type-template-args
2188 -Wunneeded-member-function
2190 -Wunsupported-visibility
2191 -Wunused-but-set-parameter
2192 -Wunused-but-set-variable
2193 -Wunused-command-line-argument
2194 -Wunused-const-variable=2
2195 -Wunused-exception-parameter
2196 -Wunused-local-typedefs
2197 -Wunused-member-function
2198 -Wunused-sanitize-argument
2199 -Wunused-volatile-lvalue
2200 -Wuser-defined-literals
2203 -Wvector-conversions
2208 ], [ TOR_CHECK_CFLAGS([warning_flag]) ])
2210 dnl We should re-enable this in some later version. Clang doesn't
2211 dnl mind, but it causes trouble with GCC.
2212 dnl -Wstrict-overflow=2
2214 dnl These seem to require annotations that we don't currently use,
2215 dnl and they give false positives in our pthreads wrappers. (Clang 4)
2217 dnl -Wthread-safety-analysis
2218 dnl -Wthread-safety-attributes
2219 dnl -Wthread-safety-beta
2220 dnl -Wthread-safety-precise
2222 CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2223 CFLAGS="$CFLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2224 CFLAGS="$CFLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2225 CFLAGS="$CFLAGS -Wwrite-strings"
2226 CFLAGS="$CFLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2227 CFLAGS="$CFLAGS -Waggregate-return -Wpacked -Wunused"
2228 CFLAGS="$CFLAGS -Wunused-parameter "
2229 # These interfere with building main() { return 0; }, which autoconf
2230 # likes to use as its default program.
2231 CFLAGS="$CFLAGS -Wold-style-definition -Wmissing-declarations"
2233 if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2234 AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2236 if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2237 AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2240 if test "x$enable_fatal_warnings" = "xyes"; then
2241 # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2242 # default autoconf programs are full of errors.
2243 CFLAGS="$CFLAGS -Werror"
2248 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2251 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.])
2255 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2260 contrib/dist/suse/tor.sh
2261 contrib/operator-tools/tor.logrotate
2264 contrib/dist/tor.service
2265 src/config/torrc.sample
2266 src/config/torrc.minimal
2267 src/rust/.cargo/config
2268 scripts/maint/checkOptionDocs.pl
2269 scripts/maint/updateVersions.pl
2272 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2273 regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2274 for file in $regular_mans ; do
2275 if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2276 echo "==================================";
2278 echo "Building Tor has failed since manpages cannot be built.";
2280 echo "You need asciidoc installed to be able to build the manpages.";
2281 echo "To build without manpages, use the --disable-asciidoc argument";
2282 echo "when calling configure.";
2284 echo "==================================";
2290 if test "$fragile_hardening" = "yes"; then
2294 Warning! Building Tor with --enable-fragile-hardening (also known as
2295 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2296 other kinds of attacks easier. A Tor instance build with this option will be
2297 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2298 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2299 denial of service attacks. For more information, see
2300 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening