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.3.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.]))
65 if test "x$enable_coverage" != "xyes" -a "x$enable_asserts_in_tests" = "xno" ; then
66 AC_MSG_ERROR([Can't disable assertions outside of coverage build])
69 AM_CONDITIONAL(UNITTESTS_ENABLED, test "x$enable_unittests" != "xno")
70 AM_CONDITIONAL(COVERAGE_ENABLED, test "x$enable_coverage" = "xyes")
71 AM_CONDITIONAL(DISABLE_ASSERTS_IN_UNIT_TESTS, test "x$enable_asserts_in_tests" = "xno")
72 AM_CONDITIONAL(LIBFUZZER_ENABLED, test "x$enable_libfuzzer" = "xyes")
73 AM_CONDITIONAL(OSS_FUZZ_ENABLED, test "x$enable_oss_fuzz" = "xyes")
74 AM_CONDITIONAL(USE_RUST, test "x$enable_rust" = "xyes")
76 if test "$enable_static_tor" = "yes"; then
77 enable_static_libevent="yes";
78 enable_static_openssl="yes";
79 enable_static_zlib="yes";
80 CFLAGS="$CFLAGS -static"
83 if test "$enable_system_torrc" = "no"; then
84 AC_DEFINE(DISABLE_SYSTEM_TORRC, 1,
85 [Defined if we're not going to look for a torrc in SYSCONF])
88 if test "$enable_memory_sentinels" = "no"; then
89 AC_DEFINE(DISABLE_MEMORY_SENTINELS, 1,
90 [Defined if we're turning off memory safety code to look for bugs])
93 AM_CONDITIONAL(USE_OPENBSD_MALLOC, test "x$enable_openbsd_malloc" = "xyes")
95 AC_ARG_ENABLE(asciidoc,
96 AS_HELP_STRING(--disable-asciidoc, [don't use asciidoc (disables building of manpages)]),
97 [case "${enableval}" in
98 "yes") asciidoc=true ;;
99 "no") asciidoc=false ;;
100 *) AC_MSG_ERROR(bad value for --disable-asciidoc) ;;
101 esac], [asciidoc=true])
103 # systemd notify support
104 AC_ARG_ENABLE(systemd,
105 AS_HELP_STRING(--enable-systemd, [enable systemd notification support]),
106 [case "${enableval}" in
107 "yes") systemd=true ;;
108 "no") systemd=false ;;
109 * ) AC_MSG_ERROR(bad value for --enable-systemd) ;;
110 esac], [systemd=auto])
112 if test "$enable_restart_debugging" = "yes"; then
113 AC_DEFINE(ENABLE_RESTART_DEBUGGING, 1,
114 [Defined if we're building with support for in-process restart debugging.])
119 if test "x$enable_systemd" = "xno"; then
122 PKG_CHECK_MODULES(SYSTEMD,
126 if test "x$have_systemd" = "xno"; then
127 AC_MSG_NOTICE([Okay, checking for systemd a different way...])
128 PKG_CHECK_MODULES(SYSTEMD,
135 if test "x$have_systemd" = "xyes"; then
136 AC_DEFINE(HAVE_SYSTEMD,1,[Have systemd])
137 TOR_SYSTEMD_CFLAGS="${SYSTEMD_CFLAGS}"
138 TOR_SYSTEMD_LIBS="${SYSTEMD_LIBS}"
139 PKG_CHECK_MODULES(LIBSYSTEMD209, [libsystemd >= 209],
140 [AC_DEFINE(HAVE_SYSTEMD_209,1,[Have systemd v209 or more])], [])
142 AC_SUBST(TOR_SYSTEMD_CFLAGS)
143 AC_SUBST(TOR_SYSTEMD_LIBS)
145 if test "x$enable_systemd" = "xyes" -a "x$have_systemd" != "xyes" ; then
146 AC_MSG_ERROR([Explicitly requested systemd support, but systemd not found])
151 AC_DEFINE(_REENTRANT, 1, [Define on some platforms to activate x_r() functions in time.h])
155 AC_ARG_ENABLE(gcc-warnings,
156 AS_HELP_STRING(--enable-gcc-warnings, [deprecated alias for enable-fatal-warnings]))
157 AC_ARG_ENABLE(fatal-warnings,
158 AS_HELP_STRING(--enable-fatal-warnings, [tell the compiler to treat all warnings as errors.]))
159 AC_ARG_ENABLE(gcc-warnings-advisory,
160 AS_HELP_STRING(--disable-gcc-warnings-advisory, [disable the regular verbose warnings]))
162 dnl Others suggest '/gs /safeseh /nxcompat /dynamicbase' for non-gcc on Windows
163 AC_ARG_ENABLE(gcc-hardening,
164 AS_HELP_STRING(--disable-gcc-hardening, [disable compiler security checks]))
166 dnl Deprecated --enable-expensive-hardening but keep it for now for backward compat.
167 AC_ARG_ENABLE(expensive-hardening,
168 AS_HELP_STRING(--enable-expensive-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
169 AC_ARG_ENABLE(fragile-hardening,
170 AS_HELP_STRING(--enable-fragile-hardening, [enable more fragile and expensive compiler hardening; makes Tor slower]))
171 if test "x$enable_expensive_hardening" = "xyes" || test "x$enable_fragile_hardening" = "xyes"; then
172 fragile_hardening="yes"
175 dnl Linker hardening options
176 dnl Currently these options are ELF specific - you can't use this with MacOSX
177 AC_ARG_ENABLE(linker-hardening,
178 AS_HELP_STRING(--disable-linker-hardening, [disable linker security fixups]))
180 AC_ARG_ENABLE(local-appdata,
181 AS_HELP_STRING(--enable-local-appdata, [default to host local application data paths on Windows]))
182 if test "$enable_local_appdata" = "yes"; then
183 AC_DEFINE(ENABLE_LOCAL_APPDATA, 1,
184 [Defined if we default to host local appdata paths on Windows])
188 AC_ARG_ENABLE(tor2web-mode,
189 AS_HELP_STRING(--enable-tor2web-mode, [support tor2web non-anonymous mode]),
190 [if test "x$enableval" = "xyes"; then
191 CFLAGS="$CFLAGS -D ENABLE_TOR2WEB_MODE=1"
194 AC_ARG_ENABLE(tool-name-check,
195 AS_HELP_STRING(--disable-tool-name-check, [check for sanely named toolchain when cross-compiling]))
197 AC_ARG_ENABLE(seccomp,
198 AS_HELP_STRING(--disable-seccomp, [do not attempt to use libseccomp]))
200 AC_ARG_ENABLE(libscrypt,
201 AS_HELP_STRING(--disable-libscrypt, [do not attempt to use libscrypt]))
203 dnl Enable event tracing which are transformed to debug log statement.
204 AC_ARG_ENABLE(event-tracing-debug,
205 AS_HELP_STRING(--enable-event-tracing-debug, [build with event tracing to debug log]))
206 AM_CONDITIONAL([USE_EVENT_TRACING_DEBUG], [test "x$enable_event_tracing_debug" = "xyes"])
208 if test x$enable_event_tracing_debug = xyes; then
209 AC_DEFINE([USE_EVENT_TRACING_DEBUG], [1], [Tracing framework to log debug])
210 AC_DEFINE([TOR_EVENT_TRACING_ENABLED], [1], [Compile the event tracing instrumentation])
213 dnl Enable Android only features.
214 AC_ARG_ENABLE(android,
215 AS_HELP_STRING(--enable-android, [build with Android features enabled]))
216 AM_CONDITIONAL([USE_ANDROID], [test "x$enable_android" = "xyes"])
218 if test "x$enable_android" = "xyes"; then
219 AC_DEFINE([USE_ANDROID], [1], [Compile with Android specific features enabled])
221 dnl Check if the Android log library is available.
222 AC_CHECK_HEADERS([android/log.h])
223 AC_SEARCH_LIBS(__android_log_write, [log])
227 dnl check for the correct "ar" when cross-compiling.
228 dnl (AM_PROG_AR was new in automake 1.11.2, which we do not yet require,
229 dnl so kludge up a replacement for the case where it isn't there yet.)
230 m4_ifdef([AM_PROG_AR],
232 [AN_MAKEVAR([AR], [AC_PROG_AR])
233 AN_PROGRAM([ar], [AC_PROG_AR])
234 AC_DEFUN([AC_PROG_AR], [AC_CHECK_TOOL([AR], [ar], [:])])
237 dnl Check whether the above macro has settled for a simply named tool even
238 dnl though we're cross compiling. We must do this before running AC_PROG_CC,
239 dnl because that will find any cc on the system, not only the cross-compiler,
240 dnl and then verify that a binary built with this compiler runs on the
241 dnl build system. It will then come to the false conclusion that we're not
243 if test "x$enable_tool_name_check" != "xno"; then
244 if test "x$ac_tool_warned" = "xyes"; then
245 AC_MSG_ERROR([We are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
246 elif test "x$ac_ct_AR" != "x" -a "x$cross_compiling" = "xmaybe"; then
247 AC_MSG_ERROR([We think we are cross compiling but could not find a properly named toolchain. Do you have your cross-compiling toolchain in PATH? (You can --disable-tool-name-check to ignore this.)])
257 AC_ARG_VAR([PERL], [path to Perl binary])
258 AC_CHECK_PROGS([PERL], [perl])
259 AM_CONDITIONAL(USE_PERL, [test "x$ac_cv_prog_PERL" != "x"])
261 dnl check for asciidoc and a2x
262 AC_PATH_PROG([ASCIIDOC], [asciidoc], none)
263 AC_PATH_PROGS([A2X], [a2x a2x.py], none)
265 AM_CONDITIONAL(USE_ASCIIDOC, test "x$asciidoc" = "xtrue")
270 AC_ARG_VAR([PYTHON], [path to Python binary])
271 AC_CHECK_PROGS(PYTHON, [python python2 python2.7 python3 python3.3])
272 if test "x$PYTHON" = "x"; then
273 AC_MSG_WARN([Python unavailable; some tests will not be run.])
275 AM_CONDITIONAL(USEPYTHON, [test "x$PYTHON" != "x"])
277 dnl List all external rust crates we depend on here. Include the version
278 rust_crates="libc-0.2.22"
279 AC_SUBST(rust_crates)
281 ifdef([AC_C_FLEXIBLE_ARRAY_MEMBER], [
282 AC_C_FLEXIBLE_ARRAY_MEMBER
284 dnl Maybe we've got an old autoconf...
285 AC_CACHE_CHECK([for flexible array members],
289 struct abc { int a; char b[]; };
291 struct abc *def = malloc(sizeof(struct abc)+sizeof(char));
294 [tor_cv_c_flexarray=yes],
295 [tor_cv_c_flexarray=no])])
296 if test "$tor_cv_flexarray" = "yes"; then
297 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
299 AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [1], [Define to nothing if C supports flexible array members, and to 1 if it does not.])
303 AC_CACHE_CHECK([for working C99 mid-block declaration syntax],
306 [AC_LANG_PROGRAM([], [int x; x = 3; int y; y = 4 + x;])],
307 [tor_cv_c_c99_decl=yes],
308 [tor_cv_c_c99_decl=no] )])
309 if test "$tor_cv_c_c99_decl" != "yes"; then
310 AC_MSG_ERROR([Your compiler doesn't support c99 mid-block declarations. This is required as of Tor 0.2.6.x])
313 AC_CACHE_CHECK([for working C99 designated initializers],
314 tor_cv_c_c99_designated_init,
316 [AC_LANG_PROGRAM([struct s { int a; int b; };],
317 [[ struct s ss = { .b = 5, .a = 6 }; ]])],
318 [tor_cv_c_c99_designated_init=yes],
319 [tor_cv_c_c99_designated_init=no] )])
321 if test "$tor_cv_c_c99_designated_init" != "yes"; then
322 AC_MSG_ERROR([Your compiler doesn't support c99 designated initializers. This is required as of Tor 0.2.6.x])
326 AC_ARG_WITH(tor-user,
327 AS_HELP_STRING(--with-tor-user=NAME, [specify username for tor daemon]),
335 AC_ARG_WITH(tor-group,
336 AS_HELP_STRING(--with-tor-group=NAME, [specify group name for tor daemon]),
344 dnl If _WIN32 is defined and non-zero, we are building for win32
345 AC_MSG_CHECKING([for win32])
346 AC_RUN_IFELSE([AC_LANG_SOURCE([
347 int main(int c, char **v) {
358 bwin32=true; AC_MSG_RESULT([yes]),
359 bwin32=false; AC_MSG_RESULT([no]),
360 bwin32=cross; AC_MSG_RESULT([cross])
363 if test "$bwin32" = "cross"; then
364 AC_MSG_CHECKING([for win32 (cross)])
365 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
367 int main(int c, char **v) {return 0;}
370 int main(int c, char **v) {return x(y);}
373 bwin32=true; AC_MSG_RESULT([yes]),
374 bwin32=false; AC_MSG_RESULT([no]))
379 /* Defined to access windows functions and definitions for >=WinXP */
381 # define WINVER 0x0501
384 /* Defined to access _other_ windows functions and definitions for >=WinXP */
385 # ifndef _WIN32_WINNT
386 # define _WIN32_WINNT 0x0501
389 /* Defined to avoid including some windows headers as part of Windows.h */
390 # ifndef WIN32_LEAN_AND_MEAN
391 # define WIN32_LEAN_AND_MEAN 1
397 AM_CONDITIONAL(BUILD_NT_SERVICES, test "x$bwin32" = "xtrue")
398 AM_CONDITIONAL(BUILD_LIBTORRUNNER, test "x$bwin32" != "xtrue")
400 dnl Enable C99 when compiling with MIPSpro
401 AC_MSG_CHECKING([for MIPSpro compiler])
402 AC_COMPILE_IFELSE([AC_LANG_PROGRAM(, [
403 #if (defined(__sgi) && defined(_COMPILER_VERSION))
408 bmipspro=false; AC_MSG_RESULT(no),
409 bmipspro=true; AC_MSG_RESULT(yes))
411 if test "$bmipspro" = "true"; then
412 CFLAGS="$CFLAGS -c99"
417 if test "x$enable_rust" = "xyes"; then
418 AC_ARG_VAR([RUSTC], [path to the rustc binary])
419 AC_CHECK_PROG([RUSTC], [rustc], [rustc],[no])
420 if test "x$RUSTC" = "xno"; then
421 AC_MSG_ERROR([rustc unavailable but rust integration requested.])
424 AC_ARG_VAR([CARGO], [path to the cargo binary])
425 AC_CHECK_PROG([CARGO], [cargo], [cargo],[no])
426 if test "x$CARGO" = "xno"; then
427 AC_MSG_ERROR([cargo unavailable but rust integration requested.])
430 AC_DEFINE([HAVE_RUST], 1, [have Rust])
431 if test "x$enable_cargo_online_mode" = "xyes"; then
435 CARGO_ONLINE=--frozen
438 dnl When we're not allowed to touch the network, we need crate dependencies
439 dnl locally available.
440 AC_MSG_CHECKING([rust crate dependencies])
441 AC_ARG_VAR([TOR_RUST_DEPENDENCIES], [path to directory with local crate mirror])
442 if test "x$TOR_RUST_DEPENDENCIES" = "x"; then
443 TOR_RUST_DEPENDENCIES="$srcdir/src/ext/rust/"
446 if test ! -d "$TOR_RUST_DEPENDENCIES"; then
447 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.])
450 for dep in $rust_crates; do
451 if test ! -d "$TOR_RUST_DEPENDENCIES"/"$dep"; then
452 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.])
456 if test "x$NEED_MOD" = "x1"; then
457 dnl When looking for dependencies from cargo, pick right directory
458 TOR_RUST_DEPENDENCIES="../../src/ext/rust"
460 if test "x$ERRORED" = "x"; then
465 dnl This is a workaround for #46797
466 dnl (a.k.a https://github.com/rust-lang/rust/issues/46797 ). Once the
467 dnl upstream bug is fixed, we can remove this workaround.
470 TOR_RUST_EXTRA_LIBS="-lresolv"
474 dnl For now both MSVC and MinGW rust libraries will output static libs with
475 dnl the MSVC naming convention.
476 if test "$bwin32" = "true"; then
477 TOR_RUST_STATIC_NAME=tor_rust.lib
479 TOR_RUST_STATIC_NAME=libtor_rust.a
482 AC_SUBST(TOR_RUST_STATIC_NAME)
483 AC_SUBST(CARGO_ONLINE)
486 dnl Let's check the rustc version, too
487 AC_MSG_CHECKING([rust version])
488 RUSTC_VERSION=`$RUSTC --version`
489 RUSTC_VERSION_MAJOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 1`
490 RUSTC_VERSION_MINOR=`$RUSTC --version | cut -d ' ' -f 2 | cut -d '.' -f 2`
491 if test "x$RUSTC_VERSION_MAJOR" = "x" -o "x$RUSTC_VERSION_MINOR" = "x"; then
492 AC_MSG_ERROR([rustc version couldn't be identified])
494 if test "$RUSTC_VERSION_MAJOR" -lt 2 -a "$RUSTC_VERSION_MINOR" -lt 14; then
495 AC_MSG_ERROR([rustc must be at least version 1.14])
497 AC_MSG_RESULT([$RUSTC_VERSION])
500 AC_SUBST(TOR_RUST_EXTRA_LIBS)
502 AC_SEARCH_LIBS(socket, [socket network])
503 AC_SEARCH_LIBS(gethostbyname, [nsl])
504 AC_SEARCH_LIBS(dlopen, [dl])
505 AC_SEARCH_LIBS(inet_aton, [resolv])
506 AC_SEARCH_LIBS(backtrace, [execinfo])
508 AC_SEARCH_LIBS([clock_gettime], [rt])
509 if test "$LIBS" != "$saved_LIBS"; then
510 # Looks like we need -lrt for clock_gettime().
514 AC_SEARCH_LIBS(pthread_create, [pthread])
515 AC_SEARCH_LIBS(pthread_detach, [pthread])
517 AM_CONDITIONAL(THREADS_WIN32, test "$bwin32" = "true")
518 AM_CONDITIONAL(THREADS_PTHREADS, test "$bwin32" = "false")
522 RtlSecureZeroMemory \
526 backtrace_symbols_fd \
532 get_current_dir_name \
539 gnu_get_libc_version \
547 mach_approximate_time \
573 # Apple messed up when they added two functions functions in Sierra: they
574 # forgot to decorate them with appropriate AVAILABLE_MAC_OS_VERSION
575 # checks. So we should only probe for those functions if we are sure that we
576 # are not targetting OSX 10.11 or earlier.
577 AC_MSG_CHECKING([for a pre-Sierra OSX build target])
578 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
580 # include <AvailabilityMacros.h>
581 # ifndef MAC_OS_X_VERSION_10_12
582 # define MAC_OS_X_VERSION_10_12 101200
584 # if defined(MAC_OS_X_VERSION_MIN_REQUIRED)
585 # if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
586 # error "Running on Mac OSX 10.11 or earlier"
591 [on_macos_pre_10_12=no ; AC_MSG_RESULT([no])],
592 [on_macos_pre_10_12=yes; AC_MSG_RESULT([yes])])
594 if test "$on_macos_pre_10_12" = "no"; then
601 if test "$bwin32" != "true"; then
602 AC_CHECK_HEADERS(pthread.h)
603 AC_CHECK_FUNCS(pthread_create)
604 AC_CHECK_FUNCS(pthread_condattr_setclock)
607 if test "$bwin32" = "true"; then
608 AC_CHECK_DECLS([SecureZeroMemory, _getwch], , , [
615 AM_CONDITIONAL(BUILD_READPASSPHRASE_C,
616 test "x$ac_cv_func_readpassphrase" = "xno" && test "$bwin32" = "false")
618 dnl ------------------------------------------------------
619 dnl Where do you live, libevent? And how do we call you?
621 if test "$bwin32" = "true"; then
622 TOR_LIB_WS32=-lws2_32
623 TOR_LIB_IPHLPAPI=-liphlpapi
624 # Some of the cargo-cults recommend -lwsock32 as well, but I don't
625 # think it's actually necessary.
627 TOR_LIB_USERENV=-luserenv
633 AC_SUBST(TOR_LIB_WS32)
634 AC_SUBST(TOR_LIB_GDI)
635 AC_SUBST(TOR_LIB_IPHLPAPI)
636 AC_SUBST(TOR_LIB_USERENV)
638 tor_libevent_pkg_redhat="libevent"
639 tor_libevent_pkg_debian="libevent-dev"
640 tor_libevent_devpkg_redhat="libevent-devel"
641 tor_libevent_devpkg_debian="libevent-dev"
643 dnl On Gnu/Linux or any place we require it, we'll add librt to the Libevent
644 dnl linking for static builds.
645 STATIC_LIBEVENT_FLAGS=""
646 if test "$enable_static_libevent" = "yes"; then
647 if test "$have_rt" = "yes"; then
648 STATIC_LIBEVENT_FLAGS=" -lrt "
652 TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32], [
654 #include <winsock2.h>
656 #include <sys/time.h>
657 #include <sys/types.h>
658 #include <event2/event.h>], [
660 #include <winsock2.h>
663 struct event_base *event_base_new(void);],
666 {WSADATA d; WSAStartup(0x101,&d); }
668 event_base_free(event_base_new());
669 ], [--with-libevent-dir], [/opt/libevent])
671 dnl Determine the incantation needed to link libevent.
673 save_LDFLAGS="$LDFLAGS"
674 save_CPPFLAGS="$CPPFLAGS"
676 LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
677 LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
678 CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
680 AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
682 if test "$enable_static_libevent" = "yes"; then
683 if test "$tor_cv_library_libevent_dir" = "(system)"; then
684 AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
686 TOR_LIBEVENT_LIBS="$TOR_LIBDIR_libevent/libevent.a $STATIC_LIBEVENT_FLAGS"
689 if test "x$ac_cv_header_event2_event_h" = "xyes"; then
690 AC_SEARCH_LIBS(event_new, [event event_core], , AC_MSG_ERROR("libevent2 is installed but linking it failed while searching for event_new"))
691 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"))
693 if test "$ac_cv_search_event_new" != "none required"; then
694 TOR_LIBEVENT_LIBS="$ac_cv_search_event_new"
696 if test "$ac_cv_search_evdns_base_new" != "none required"; then
697 TOR_LIBEVENT_LIBS="$ac_cv_search_evdns_base_new $TOR_LIBEVENT_LIBS"
700 AC_MSG_ERROR("libevent2 is required but the headers could not be found")
704 dnl Now check for particular libevent functions.
705 AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file \
706 evutil_secure_rng_add_bytes \
710 LDFLAGS="$save_LDFLAGS"
711 CPPFLAGS="$save_CPPFLAGS"
713 dnl Check that libevent is at least at version 2.0.10, the first stable
714 dnl release of its series
715 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
716 AC_MSG_CHECKING([whether Libevent is new enough])
717 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
718 #include <event2/event.h>
719 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
725 ])], [ AC_MSG_RESULT([yes]) ],
726 [ AC_MSG_RESULT([no])
727 AC_MSG_ERROR([Libevent is not new enough. We require 2.0.10-stable or later]) ] )
730 LDFLAGS="$save_LDFLAGS"
731 CPPFLAGS="$save_CPPFLAGS"
733 AC_SUBST(TOR_LIBEVENT_LIBS)
735 dnl ------------------------------------------------------
736 dnl Where do you live, libm?
738 dnl On some platforms (Haiku/BeOS) the math library is
739 dnl part of libroot. In which case don't link against lm
742 AC_SEARCH_LIBS(pow, [m], , AC_MSG_ERROR([Could not find pow in libm or libc.]))
743 if test "$ac_cv_search_pow" != "none required"; then
744 TOR_LIB_MATH="$ac_cv_search_pow"
747 AC_SUBST(TOR_LIB_MATH)
749 dnl ------------------------------------------------------
750 dnl Where do you live, openssl? And how do we call you?
752 tor_openssl_pkg_redhat="openssl"
753 tor_openssl_pkg_debian="libssl-dev"
754 tor_openssl_devpkg_redhat="openssl-devel"
755 tor_openssl_devpkg_debian="libssl-dev"
757 ALT_openssl_WITHVAL=""
759 AS_HELP_STRING(--with-ssl-dir=PATH, [obsolete alias for --with-openssl-dir]),
761 if test "x$withval" != "xno" && test "x$withval" != "x"; then
762 ALT_openssl_WITHVAL="$withval"
766 AC_MSG_NOTICE([Now, we'll look for OpenSSL >= 1.0.1])
767 TOR_SEARCH_LIBRARY(openssl, $tryssldir, [-lssl -lcrypto $TOR_LIB_GDI $TOR_LIB_WS32],
768 [#include <openssl/ssl.h>],
769 [struct ssl_method_st; const struct ssl_method_st *TLSv1_1_method(void);],
770 [TLSv1_1_method();], [],
771 [/usr/local/opt/openssl /usr/local/openssl /usr/lib/openssl /usr/local/ssl /usr/lib/ssl /usr/local /opt/openssl])
773 dnl XXXX check for OPENSSL_VERSION_NUMBER == SSLeay()
775 if test "$enable_static_openssl" = "yes"; then
776 if test "$tor_cv_library_openssl_dir" = "(system)"; then
777 AC_MSG_ERROR("You must specify an explicit --with-openssl-dir=x option when using --enable-static-openssl")
779 TOR_OPENSSL_LIBS="$TOR_LIBDIR_openssl/libssl.a $TOR_LIBDIR_openssl/libcrypto.a"
782 TOR_OPENSSL_LIBS="-lssl -lcrypto"
784 AC_SUBST(TOR_OPENSSL_LIBS)
786 dnl Now check for particular openssl functions.
788 save_LDFLAGS="$LDFLAGS"
789 save_CPPFLAGS="$CPPFLAGS"
790 LIBS="$TOR_OPENSSL_LIBS $LIBS"
791 LDFLAGS="$TOR_LDFLAGS_openssl $LDFLAGS"
792 CPPFLAGS="$TOR_CPPFLAGS_openssl $CPPFLAGS"
794 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
795 #include <openssl/opensslv.h>
796 #if !defined(LIBRESSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x1000100fL
801 [ 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.]) ])
803 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
804 #include <openssl/opensslv.h>
805 #include <openssl/evp.h>
806 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_ECDH) || defined(OPENSSL_NO_ECDSA)
809 #if !defined(NID_X9_62_prime256v1) || !defined(NID_secp224r1)
810 #error "curves unavailable"
814 [ 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.]) ])
816 AC_CHECK_MEMBERS([struct ssl_method_st.get_cipher_by_char], , ,
817 [#include <openssl/ssl.h>
821 SSL_SESSION_get_master_key \
822 SSL_get_server_random \
823 SSL_get_client_ciphers \
824 SSL_get_client_random \
829 dnl Check if OpenSSL has scrypt implementation.
830 AC_CHECK_FUNCS([ EVP_PBE_scrypt ])
832 dnl Check if OpenSSL structures are opaque
833 AC_CHECK_MEMBERS([SSL.state], , ,
834 [#include <openssl/ssl.h>
837 dnl Define the set of checks for KIST scheduler support.
838 AC_DEFUN([CHECK_KIST_SUPPORT],[
839 dnl KIST needs struct tcp_info and for certain members to exist.
841 [struct tcp_info.tcpi_unacked, struct tcp_info.tcpi_snd_mss],
842 , ,[[#include <netinet/tcp.h>]])
843 dnl KIST needs SIOCOUTQNSD to exist for an ioctl call.
844 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
845 #include <linux/sockios.h>
849 ])], have_siocoutqnsd=yes, have_siocoutqnsd=no)
850 if test "x$have_siocoutqnsd" = "xyes"; then
851 if test "x$ac_cv_member_struct_tcp_info_tcpi_unacked" = "xyes"; then
852 if test "x$ac_cv_member_struct_tcp_info_tcpi_snd_mss" = "xyes"; then
853 have_kist_support=yes
858 dnl Now, trigger the check.
860 AS_IF([test "x$have_kist_support" = "xyes"],
861 [AC_DEFINE(HAVE_KIST_SUPPORT, 1, [Defined if KIST scheduler is supported
863 [AC_MSG_NOTICE([KIST scheduler can't be used. Missing support.])])
866 LDFLAGS="$save_LDFLAGS"
867 CPPFLAGS="$save_CPPFLAGS"
869 dnl ------------------------------------------------------
870 dnl Where do you live, zlib? And how do we call you?
872 tor_zlib_pkg_redhat="zlib"
873 tor_zlib_pkg_debian="zlib1g"
874 tor_zlib_devpkg_redhat="zlib-devel"
875 tor_zlib_devpkg_debian="zlib1g-dev"
877 TOR_SEARCH_LIBRARY(zlib, $tryzlibdir, [-lz],
879 [const char * zlibVersion(void);],
880 [zlibVersion();], [--with-zlib-dir],
883 if test "$enable_static_zlib" = "yes"; then
884 if test "$tor_cv_library_zlib_dir" = "(system)"; then
885 AC_MSG_ERROR("You must specify an explicit --with-zlib-dir=x option when
886 using --enable-static-zlib")
888 TOR_ZLIB_LIBS="$TOR_LIBDIR_zlib/libz.a"
893 AC_SUBST(TOR_ZLIB_LIBS)
895 dnl ------------------------------------------------------
896 dnl Where we do we find lzma?
899 AS_HELP_STRING(--enable-lzma, [enable support for the LZMA compression scheme.]),
900 [case "${enableval}" in
903 * ) AC_MSG_ERROR(bad value for --enable-lzma) ;;
906 if test "x$enable_lzma" = "xno"; then
909 PKG_CHECK_MODULES([LZMA],
914 if test "x$have_lzma" = "xno" ; then
915 AC_MSG_WARN([Unable to find liblzma.])
919 if test "x$have_lzma" = "xyes"; then
920 AC_DEFINE(HAVE_LZMA,1,[Have LZMA])
921 TOR_LZMA_CFLAGS="${LZMA_CFLAGS}"
922 TOR_LZMA_LIBS="${LZMA_LIBS}"
924 AC_SUBST(TOR_LZMA_CFLAGS)
925 AC_SUBST(TOR_LZMA_LIBS)
927 dnl ------------------------------------------------------
928 dnl Where we do we find zstd?
931 AS_HELP_STRING(--enable-zstd, [enable support for the Zstandard compression scheme.]),
932 [case "${enableval}" in
935 * ) AC_MSG_ERROR(bad value for --enable-zstd) ;;
938 if test "x$enable_zstd" = "xno"; then
941 PKG_CHECK_MODULES([ZSTD],
946 if test "x$have_zstd" = "xno" ; then
947 AC_MSG_WARN([Unable to find libzstd.])
951 if test "x$have_zstd" = "xyes"; then
952 AC_DEFINE(HAVE_ZSTD,1,[Have Zstd])
953 TOR_ZSTD_CFLAGS="${ZSTD_CFLAGS}"
954 TOR_ZSTD_LIBS="${ZSTD_LIBS}"
956 AC_SUBST(TOR_ZSTD_CFLAGS)
957 AC_SUBST(TOR_ZSTD_LIBS)
959 dnl ----------------------------------------------------------------------
960 dnl Check if libcap is available for capabilities.
962 tor_cap_pkg_debian="libcap2"
963 tor_cap_pkg_redhat="libcap"
964 tor_cap_devpkg_debian="libcap-dev"
965 tor_cap_devpkg_redhat="libcap-devel"
967 AC_CHECK_LIB([cap], [cap_init], [],
968 AC_MSG_NOTICE([Libcap was not found. Capabilities will not be usable.])
970 AC_CHECK_FUNCS(cap_set_proc)
972 dnl ---------------------------------------------------------------------
973 dnl Now that we know about our major libraries, we can check for compiler
974 dnl and linker hardening options. We need to do this with the libraries known,
975 dnl since sometimes the linker will like an option but not be willing to
976 dnl use it with a build of a library.
978 all_ldflags_for_check="$TOR_LDFLAGS_zlib $TOR_LDFLAGS_openssl $TOR_LDFLAGS_libevent"
979 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"
987 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
988 #if !defined(__clang__)
990 #endif])], have_clang=yes, have_clang=no)
992 if test "x$enable_gcc_hardening" != "xno"; then
993 CFLAGS="$CFLAGS -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
994 if test "x$have_clang" = "xyes"; then
995 TOR_CHECK_CFLAGS(-Qunused-arguments)
997 TOR_CHECK_CFLAGS(-fstack-protector-all, also_link)
998 AS_VAR_PUSHDEF([can_compile], [tor_cv_cflags_-fstack-protector-all])
999 AS_VAR_PUSHDEF([can_link], [tor_can_link_-fstack-protector-all])
1000 m4_ifdef([AS_VAR_IF],[
1001 AS_VAR_IF(can_compile, [yes],
1002 AS_VAR_IF(can_link, [yes],
1004 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.)]))
1006 AS_VAR_POPDEF([can_link])
1007 AS_VAR_POPDEF([can_compile])
1008 TOR_CHECK_CFLAGS(-Wstack-protector)
1009 TOR_CHECK_CFLAGS(--param ssp-buffer-size=1)
1010 if test "$bwin32" = "false" && test "$enable_libfuzzer" != "yes" && test "$enable_oss_fuzz" != "yes"; then
1011 TOR_CHECK_CFLAGS(-fPIE)
1012 TOR_CHECK_LDFLAGS(-pie, "$all_ldflags_for_check", "$all_libs_for_check")
1014 TOR_TRY_COMPILE_WITH_CFLAGS(-fwrapv, also_link, CFLAGS_FWRAPV="-fwrapv", true)
1017 if test "$fragile_hardening" = "yes"; then
1018 TOR_TRY_COMPILE_WITH_CFLAGS(-ftrapv, also_link, CFLAGS_FTRAPV="-ftrapv", true)
1019 if test "$tor_cv_cflags__ftrapv" = "yes" && test "$tor_can_link__ftrapv" != "yes"; then
1020 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.])
1023 if test "$tor_cv_cflags__ftrapv" != "yes"; then
1024 AC_MSG_ERROR([You requested fragile hardening, but the compiler does not seem to support -ftrapv.])
1027 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=address], also_link, CFLAGS_ASAN="-fsanitize=address", true)
1028 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1029 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*])
1032 TOR_TRY_COMPILE_WITH_CFLAGS([-fsanitize=undefined], also_link, CFLAGS_UBSAN="-fsanitize=undefined", true)
1033 if test "$tor_cv_cflags__fsanitize_address" = "yes" && test "$tor_can_link__fsanitize_address" != "yes"; then
1034 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*])
1037 TOR_CHECK_CFLAGS([-fno-omit-frame-pointer])
1040 CFLAGS_BUGTRAP="$CFLAGS_FTRAPV $CFLAGS_ASAN $CFLAGS_UBSAN"
1041 CFLAGS_CONSTTIME="$CFLAGS_FWRAPV"
1043 mulodi_fixes_ftrapv=no
1044 if test "$have_clang" = "yes"; then
1045 saved_CFLAGS="$CFLAGS"
1046 CFLAGS="$CFLAGS $CFLAGS_FTRAPV"
1047 AC_MSG_CHECKING([whether clang -ftrapv can link a 64-bit int multiply])
1052 int main(int argc, char **argv)
1054 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1055 * (int64_t)atoi(argv[3]);
1058 [ftrapv_can_link=yes; AC_MSG_RESULT([yes])],
1059 [ftrapv_can_link=no; AC_MSG_RESULT([no])])
1060 if test "$ftrapv_can_link" = "no"; then
1061 AC_MSG_CHECKING([whether defining __mulodi4 fixes that])
1066 int64_t __mulodi4(int64_t a, int64_t b, int *overflow) {
1070 int main(int argc, char **argv)
1072 int64_t x = ((int64_t)atoi(argv[1])) * (int64_t)atoi(argv[2])
1073 * (int64_t)atoi(argv[3]);
1076 [mulodi_fixes_ftrapv=yes; AC_MSG_RESULT([yes])],
1077 [mulodi_fixes_ftrapv=no; AC_MSG_RESULT([no])])
1079 CFLAGS="$saved_CFLAGS"
1082 AM_CONDITIONAL(ADD_MULODI4, test "$mulodi_fixes_ftrapv" = "yes")
1084 dnl These cflags add bunches of branches, and we haven't been able to
1085 dnl persuade ourselves that they're suitable for code that needs to be
1087 AC_SUBST(CFLAGS_BUGTRAP)
1088 dnl These cflags are variant ones sutable for code that needs to be
1090 AC_SUBST(CFLAGS_CONSTTIME)
1092 if test "x$enable_linker_hardening" != "xno"; then
1093 TOR_CHECK_LDFLAGS(-z relro -z now, "$all_ldflags_for_check", "$all_libs_for_check")
1096 # For backtrace support
1097 TOR_CHECK_LDFLAGS(-rdynamic)
1099 dnl ------------------------------------------------------
1100 dnl Now see if we have a -fomit-frame-pointer compiler option.
1102 saved_CFLAGS="$CFLAGS"
1103 TOR_CHECK_CFLAGS(-fomit-frame-pointer)
1104 F_OMIT_FRAME_POINTER=''
1105 if test "$saved_CFLAGS" != "$CFLAGS"; then
1106 if test "$fragile_hardening" = "yes"; then
1107 F_OMIT_FRAME_POINTER='-fomit-frame-pointer'
1110 CFLAGS="$saved_CFLAGS"
1111 AC_SUBST(F_OMIT_FRAME_POINTER)
1113 dnl ------------------------------------------------------
1114 dnl If we are adding -fomit-frame-pointer (or if the compiler's doing it
1115 dnl for us, as GCC 4.6 and later do at many optimization levels), then
1116 dnl we should try to add -fasynchronous-unwind-tables so that our backtrace
1118 TOR_CHECK_CFLAGS(-fasynchronous-unwind-tables)
1120 dnl ============================================================
1121 dnl Check for libseccomp
1123 if test "x$enable_seccomp" != "xno"; then
1124 AC_CHECK_HEADERS([seccomp.h])
1125 AC_SEARCH_LIBS(seccomp_init, [seccomp])
1128 dnl ============================================================
1129 dnl Check for libscrypt
1131 if test "x$enable_libscrypt" != "xno"; then
1132 AC_CHECK_HEADERS([libscrypt.h])
1133 AC_SEARCH_LIBS(libscrypt_scrypt, [scrypt])
1134 AC_CHECK_FUNCS([libscrypt_scrypt])
1137 dnl ============================================================
1138 dnl We need an implementation of curve25519.
1140 dnl set these defaults.
1141 build_curve25519_donna=no
1142 build_curve25519_donna_c64=no
1143 use_curve25519_donna=no
1144 use_curve25519_nacl=no
1147 dnl The best choice is using curve25519-donna-c64, but that requires
1149 AC_CACHE_CHECK([whether we can use curve25519-donna-c64],
1150 tor_cv_can_use_curve25519_donna_c64,
1152 [AC_LANG_PROGRAM([dnl
1154 typedef unsigned uint128_t __attribute__((mode(TI)));
1155 int func(uint64_t a, uint64_t b) {
1156 uint128_t c = ((uint128_t)a) * b;
1157 int ok = ((uint64_t)(c>>96)) == 522859 &&
1158 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1159 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1160 (((uint64_t)(c))&0xffffffffL) == 0;
1164 int ok = func( ((uint64_t)2000000000) * 1000000000,
1165 ((uint64_t)1234567890) << 24);
1168 [tor_cv_can_use_curve25519_donna_c64=yes],
1169 [tor_cv_can_use_curve25519_donna_c64=no],
1171 [AC_LANG_PROGRAM([dnl
1173 typedef unsigned uint128_t __attribute__((mode(TI)));
1174 int func(uint64_t a, uint64_t b) {
1175 uint128_t c = ((uint128_t)a) * b;
1176 int ok = ((uint64_t)(c>>96)) == 522859 &&
1177 (((uint64_t)(c>>64))&0xffffffffL) == 3604448702L &&
1178 (((uint64_t)(c>>32))&0xffffffffL) == 2351960064L &&
1179 (((uint64_t)(c))&0xffffffffL) == 0;
1183 int ok = func( ((uint64_t)2000000000) * 1000000000,
1184 ((uint64_t)1234567890) << 24);
1187 [tor_cv_can_use_curve25519_donna_c64=cross],
1188 [tor_cv_can_use_curve25519_donna_c64=no])])])
1190 AC_CHECK_HEADERS([crypto_scalarmult_curve25519.h \
1191 nacl/crypto_scalarmult_curve25519.h])
1193 AC_CACHE_CHECK([for nacl compiled with a fast curve25519 implementation],
1194 tor_cv_can_use_curve25519_nacl,
1195 [tor_saved_LIBS="$LIBS"
1198 [AC_LANG_PROGRAM([dnl
1199 #ifdef HAVE_CRYPTO_SCALARMULT_CURVE25519_H
1200 #include <crypto_scalarmult_curve25519.h>
1201 #elif defined(HAVE_NACL_CRYPTO_SCALARMULT_CURVE25519_H)
1202 #include <nacl/crypto_scalarmult_curve25519.h>
1204 #ifdef crypto_scalarmult_curve25519_ref_BYTES
1205 #error Hey, this is the reference implementation! That's not fast.
1208 unsigned char *a, *b, *c; crypto_scalarmult_curve25519(a,b,c);
1209 ])], [tor_cv_can_use_curve25519_nacl=yes],
1210 [tor_cv_can_use_curve25519_nacl=no])
1211 LIBS="$tor_saved_LIBS" ])
1213 dnl Okay, now we need to figure out which one to actually use. Fall back
1214 dnl to curve25519-donna.c
1216 if test "x$tor_cv_can_use_curve25519_donna_c64" != "xno"; then
1217 build_curve25519_donna_c64=yes
1218 use_curve25519_donna=yes
1219 elif test "x$tor_cv_can_use_curve25519_nacl" = "xyes"; then
1220 use_curve25519_nacl=yes
1221 CURVE25519_LIBS=-lnacl
1223 build_curve25519_donna=yes
1224 use_curve25519_donna=yes
1227 if test "x$use_curve25519_donna" = "xyes"; then
1228 AC_DEFINE(USE_CURVE25519_DONNA, 1,
1229 [Defined if we should use an internal curve25519_donna{,_c64} implementation])
1231 if test "x$use_curve25519_nacl" = "xyes"; then
1232 AC_DEFINE(USE_CURVE25519_NACL, 1,
1233 [Defined if we should use a curve25519 from nacl])
1235 AM_CONDITIONAL(BUILD_CURVE25519_DONNA,
1236 test "x$build_curve25519_donna" = "xyes")
1237 AM_CONDITIONAL(BUILD_CURVE25519_DONNA_C64,
1238 test "x$build_curve25519_donna_c64" = "xyes")
1239 AC_SUBST(CURVE25519_LIBS)
1241 dnl Make sure to enable support for large off_t if available.
1244 AC_CHECK_HEADERS([assert.h \
1259 gnu/libc-version.h \
1299 AC_CHECK_HEADERS(sys/param.h)
1301 AC_CHECK_HEADERS(net/if.h, net_if_found=1, net_if_found=0,
1302 [#ifdef HAVE_SYS_TYPES_H
1303 #include <sys/types.h>
1305 #ifdef HAVE_SYS_SOCKET_H
1306 #include <sys/socket.h>
1308 AC_CHECK_HEADERS(net/pfvar.h, net_pfvar_found=1, net_pfvar_found=0,
1309 [#ifdef HAVE_SYS_TYPES_H
1310 #include <sys/types.h>
1312 #ifdef HAVE_SYS_SOCKET_H
1313 #include <sys/socket.h>
1315 #ifdef HAVE_NET_IF_H
1318 #ifdef HAVE_NETINET_IN_H
1319 #include <netinet/in.h>
1322 AC_CHECK_HEADERS(linux/if.h,[],[],
1324 #ifdef HAVE_SYS_SOCKET_H
1325 #include <sys/socket.h>
1329 AC_CHECK_HEADERS(linux/netfilter_ipv4.h,
1330 linux_netfilter_ipv4=1, linux_netfilter_ipv4=0,
1331 [#ifdef HAVE_SYS_TYPES_H
1332 #include <sys/types.h>
1334 #ifdef HAVE_SYS_SOCKET_H
1335 #include <sys/socket.h>
1337 #ifdef HAVE_LIMITS_H
1340 #ifdef HAVE_LINUX_TYPES_H
1341 #include <linux/types.h>
1343 #ifdef HAVE_NETINET_IN6_H
1344 #include <netinet/in6.h>
1346 #ifdef HAVE_NETINET_IN_H
1347 #include <netinet/in.h>
1350 AC_CHECK_HEADERS(linux/netfilter_ipv6/ip6_tables.h,
1351 linux_netfilter_ipv6_ip6_tables=1, linux_netfilter_ipv6_ip6_tables=0,
1352 [#ifdef HAVE_SYS_TYPES_H
1353 #include <sys/types.h>
1355 #ifdef HAVE_SYS_SOCKET_H
1356 #include <sys/socket.h>
1358 #ifdef HAVE_LIMITS_H
1361 #ifdef HAVE_LINUX_TYPES_H
1362 #include <linux/types.h>
1364 #ifdef HAVE_NETINET_IN6_H
1365 #include <netinet/in6.h>
1367 #ifdef HAVE_NETINET_IN_H
1368 #include <netinet/in.h>
1370 #ifdef HAVE_LINUX_IF_H
1371 #include <linux/if.h>
1375 if test "x$net_if_found" = "x1" && test "x$net_pfvar_found" = "x1"; then
1378 if test "x$linux_netfilter_ipv4" = "x1"; then
1381 if test "x$linux_netfilter_ipv6_ip6_tables" = "x1"; then
1384 if test "x$transparent_ok" = "x1"; then
1385 AC_DEFINE(USE_TRANSPARENT, 1, "Define to enable transparent proxy support")
1387 AC_MSG_NOTICE([Transparent proxy support enabled, but missing headers.])
1390 AC_CHECK_MEMBERS([struct timeval.tv_sec], , ,
1391 [#ifdef HAVE_SYS_TYPES_H
1392 #include <sys/types.h>
1394 #ifdef HAVE_SYS_TIME_H
1395 #include <sys/time.h>
1398 dnl In case we aren't given a working stdint.h, we'll need to grow our own.
1401 AC_CHECK_SIZEOF(int8_t)
1402 AC_CHECK_SIZEOF(int16_t)
1403 AC_CHECK_SIZEOF(int32_t)
1404 AC_CHECK_SIZEOF(int64_t)
1405 AC_CHECK_SIZEOF(uint8_t)
1406 AC_CHECK_SIZEOF(uint16_t)
1407 AC_CHECK_SIZEOF(uint32_t)
1408 AC_CHECK_SIZEOF(uint64_t)
1409 AC_CHECK_SIZEOF(intptr_t)
1410 AC_CHECK_SIZEOF(uintptr_t)
1412 dnl AC_CHECK_TYPES([int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, intptr_t, uintptr_t])
1414 AC_CHECK_SIZEOF(char)
1415 AC_CHECK_SIZEOF(short)
1416 AC_CHECK_SIZEOF(int)
1417 AC_CHECK_SIZEOF(long)
1418 AC_CHECK_SIZEOF(long long)
1419 AC_CHECK_SIZEOF(__int64)
1420 AC_CHECK_SIZEOF(void *)
1421 AC_CHECK_SIZEOF(time_t)
1422 AC_CHECK_SIZEOF(size_t)
1423 AC_CHECK_SIZEOF(pid_t)
1425 AC_CHECK_TYPES([uint, u_char, ssize_t])
1427 AC_PC_FROM_UCONTEXT([:])
1429 dnl used to include sockaddr_storage, but everybody has that.
1430 AC_CHECK_TYPES([struct in6_addr, struct sockaddr_in6, sa_family_t], , ,
1431 [#ifdef HAVE_SYS_TYPES_H
1432 #include <sys/types.h>
1434 #ifdef HAVE_NETINET_IN_H
1435 #include <netinet/in.h>
1437 #ifdef HAVE_NETINET_IN6_H
1438 #include <netinet/in6.h>
1440 #ifdef HAVE_SYS_SOCKET_H
1441 #include <sys/socket.h>
1444 #define _WIN32_WINNT 0x0501
1445 #define WIN32_LEAN_AND_MEAN
1446 #include <winsock2.h>
1447 #include <ws2tcpip.h>
1450 AC_CHECK_MEMBERS([struct in6_addr.s6_addr32, struct in6_addr.s6_addr16, struct sockaddr_in.sin_len, struct sockaddr_in6.sin6_len], , ,
1451 [#ifdef HAVE_SYS_TYPES_H
1452 #include <sys/types.h>
1454 #ifdef HAVE_NETINET_IN_H
1455 #include <netinet/in.h>
1457 #ifdef HAVE_NETINET_IN6_H
1458 #include <netinet/in6.h>
1460 #ifdef HAVE_SYS_SOCKET_H
1461 #include <sys/socket.h>
1464 #define _WIN32_WINNT 0x0501
1465 #define WIN32_LEAN_AND_MEAN
1466 #include <winsock2.h>
1467 #include <ws2tcpip.h>
1471 AC_CHECK_TYPES([rlim_t], , ,
1472 [#ifdef HAVE_SYS_TYPES_H
1473 #include <sys/types.h>
1475 #ifdef HAVE_SYS_TIME_H
1476 #include <sys/time.h>
1478 #ifdef HAVE_SYS_RESOURCE_H
1479 #include <sys/resource.h>
1483 AX_CHECK_SIGN([time_t],
1486 #ifdef HAVE_SYS_TYPES_H
1487 #include <sys/types.h>
1489 #ifdef HAVE_SYS_TIME_H
1490 #include <sys/time.h>
1497 if test "$ax_cv_decl_time_t_signed" = "no"; then
1498 AC_MSG_ERROR([You have an unsigned time_t; Tor does not support that. Please tell the Tor developers about your interesting platform.])
1501 AX_CHECK_SIGN([size_t],
1502 [ tor_cv_size_t_signed=yes ],
1503 [ tor_cv_size_t_signed=no ], [
1504 #ifdef HAVE_SYS_TYPES_H
1505 #include <sys/types.h>
1509 if test "$ax_cv_decl_size_t_signed" = "yes"; then
1510 AC_MSG_ERROR([You have a signed size_t; that's grossly nonconformant.])
1513 AX_CHECK_SIGN([enum always],
1514 [ AC_DEFINE(ENUM_VALS_ARE_SIGNED, 1, [Define if enum is always signed]) ],
1516 enum always { AAA, BBB, CCC };
1519 AC_CHECK_SIZEOF(socklen_t, , [AC_INCLUDES_DEFAULT()
1520 #ifdef HAVE_SYS_SOCKET_H
1521 #include <sys/socket.h>
1525 # We want to make sure that we _don't_ have a cell_t defined, like IRIX does.
1527 AC_CHECK_SIZEOF(cell_t)
1529 # Now make sure that NULL can be represented as zero bytes.
1530 AC_CACHE_CHECK([whether memset(0) sets pointers to NULL], tor_cv_null_is_zero,
1531 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1532 [[#include <stdlib.h>
1535 #ifdef HAVE_STDDEF_H
1538 int main () { char *p1,*p2; p1=NULL; memset(&p2,0,sizeof(p2));
1539 return memcmp(&p1,&p2,sizeof(char*))?1:0; }]])],
1540 [tor_cv_null_is_zero=yes],
1541 [tor_cv_null_is_zero=no],
1542 [tor_cv_null_is_zero=cross])])
1544 if test "$tor_cv_null_is_zero" = "cross"; then
1545 # Cross-compiling; let's hope that the target isn't raving mad.
1546 AC_MSG_NOTICE([Cross-compiling: we'll assume that NULL is represented as a sequence of 0-valued bytes.])
1549 if test "$tor_cv_null_is_zero" != "no"; then
1550 AC_DEFINE([NULL_REP_IS_ZERO_BYTES], 1,
1551 [Define to 1 iff memset(0) sets pointers to NULL])
1554 AC_CACHE_CHECK([whether memset(0) sets doubles to 0.0], tor_cv_dbl0_is_zero,
1555 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1556 [[#include <stdlib.h>
1559 #ifdef HAVE_STDDEF_H
1562 int main () { double d1,d2; d1=0; memset(&d2,0,sizeof(d2));
1563 return memcmp(&d1,&d2,sizeof(d1))?1:0; }]])],
1564 [tor_cv_dbl0_is_zero=yes],
1565 [tor_cv_dbl0_is_zero=no],
1566 [tor_cv_dbl0_is_zero=cross])])
1568 if test "$tor_cv_dbl0_is_zero" = "cross"; then
1569 # Cross-compiling; let's hope that the target isn't raving mad.
1570 AC_MSG_NOTICE([Cross-compiling: we'll assume that 0.0 can be represented as a sequence of 0-valued bytes.])
1573 if test "$tor_cv_dbl0_is_zero" != "no"; then
1574 AC_DEFINE([DOUBLE_0_REP_IS_ZERO_BYTES], 1,
1575 [Define to 1 iff memset(0) sets doubles to 0.0])
1578 # And what happens when we malloc zero?
1579 AC_CACHE_CHECK([whether we can malloc(0) safely.], tor_cv_malloc_zero_works,
1580 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1581 [[#include <stdlib.h>
1584 #ifdef HAVE_STDDEF_H
1587 int main () { return malloc(0)?0:1; }]])],
1588 [tor_cv_malloc_zero_works=yes],
1589 [tor_cv_malloc_zero_works=no],
1590 [tor_cv_malloc_zero_works=cross])])
1592 if test "$tor_cv_malloc_zero_works" = "cross"; then
1593 # Cross-compiling; let's hope that the target isn't raving mad.
1594 AC_MSG_NOTICE([Cross-compiling: we'll assume that we need to check malloc() arguments for 0.])
1597 if test "$tor_cv_malloc_zero_works" = "yes"; then
1598 AC_DEFINE([MALLOC_ZERO_WORKS], 1,
1599 [Define to 1 iff malloc(0) returns a pointer])
1602 # whether we seem to be in a 2s-complement world.
1603 AC_CACHE_CHECK([whether we are using 2s-complement arithmetic], tor_cv_twos_complement,
1604 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1605 [[int main () { int problem = ((-99) != (~99)+1);
1606 return problem ? 1 : 0; }]])],
1607 [tor_cv_twos_complement=yes],
1608 [tor_cv_twos_complement=no],
1609 [tor_cv_twos_complement=cross])])
1611 if test "$tor_cv_twos_complement" = "cross"; then
1612 # Cross-compiling; let's hope that the target isn't raving mad.
1613 AC_MSG_NOTICE([Cross-compiling: we'll assume that negative integers are represented with two's complement.])
1616 if test "$tor_cv_twos_complement" != "no"; then
1617 AC_DEFINE([USING_TWOS_COMPLEMENT], 1,
1618 [Define to 1 iff we represent negative integers with
1622 # What does shifting a negative value do?
1623 AC_CACHE_CHECK([whether right-shift on negative values does sign-extension], tor_cv_sign_extend,
1624 [AC_RUN_IFELSE([AC_LANG_SOURCE(
1625 [[int main () { int okay = (-60 >> 8) == -1; return okay ? 0 : 1; }]])],
1626 [tor_cv_sign_extend=yes],
1627 [tor_cv_sign_extend=no],
1628 [tor_cv_sign_extend=cross])])
1630 if test "$tor_cv_sign_extend" = "cross"; then
1631 # Cross-compiling; let's hope that the target isn't raving mad.
1632 AC_MSG_NOTICE([Cross-compiling: we'll assume that right-shifting negative integers causes sign-extension])
1635 if test "$tor_cv_sign_extend" != "no"; then
1636 AC_DEFINE([RSHIFT_DOES_SIGN_EXTEND], 1,
1637 [Define to 1 iff right-shifting a negative value performs sign-extension])
1640 # Is uint8_t the same type as unsigned char?
1641 AC_CACHE_CHECK([whether uint8_t is the same type as unsigned char], tor_cv_uint8_uchar,
1642 [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
1645 unsigned char c;]])],
1646 [tor_cv_uint8_uchar=yes],
1647 [tor_cv_uint8_uchar=no],
1648 [tor_cv_uint8_uchar=cross])])
1650 if test "$tor_cv_uint8_uchar" = "cross"; then
1651 AC_MSG_NOTICE([Cross-compiling: we'll assume that uint8_t is the same type as unsigned char])
1654 if test "$tor_cv_uint8_uchar" = "no"; then
1655 AC_MSG_ERROR([We assume that uint8_t is the same type as unsigned char, but your compiler disagrees.])
1658 # Whether we should use the dmalloc memory allocation debugging library.
1659 AC_MSG_CHECKING(whether to use dmalloc (debug memory allocation library))
1660 AC_ARG_WITH(dmalloc,
1661 AS_HELP_STRING(--with-dmalloc, [use debug memory allocation library]),
1662 [if [[ "$withval" = "yes" ]]; then
1668 fi], [ dmalloc=0; AC_MSG_RESULT(no) ]
1671 if [[ $dmalloc -eq 1 ]]; then
1672 AC_CHECK_HEADERS(dmalloc.h, , AC_MSG_ERROR(dmalloc header file not found. Do you have the development files for dmalloc installed?))
1673 AC_SEARCH_LIBS(dmalloc_malloc, [dmallocth dmalloc], , AC_MSG_ERROR(Libdmalloc library not found. If you enable it you better have it installed.))
1674 AC_DEFINE(USE_DMALLOC, 1, [Debug memory allocation library])
1675 AC_CHECK_FUNCS(dmalloc_strdup dmalloc_strndup)
1678 AC_ARG_WITH(tcmalloc,
1679 AS_HELP_STRING(--with-tcmalloc, [use tcmalloc memory allocation library]),
1680 [ tcmalloc=yes ], [ tcmalloc=no ])
1682 if test "x$tcmalloc" = "xyes"; then
1683 LDFLAGS="-ltcmalloc $LDFLAGS"
1686 using_custom_malloc=no
1687 if test "x$enable_openbsd_malloc" = "xyes"; then
1688 using_custom_malloc=yes
1690 if test "x$tcmalloc" = "xyes"; then
1691 using_custom_malloc=yes
1693 if test "$using_custom_malloc" = "no"; then
1694 AC_CHECK_FUNCS(mallinfo)
1697 # By default, we're going to assume we don't have mlockall()
1698 # bionic and other platforms have various broken mlockall subsystems.
1699 # Some systems don't have a working mlockall, some aren't linkable,
1700 # and some have it but don't declare it.
1701 AC_CHECK_FUNCS(mlockall)
1702 AC_CHECK_DECLS([mlockall], , , [
1703 #ifdef HAVE_SYS_MMAN_H
1704 #include <sys/mman.h>
1707 # Some MinGW environments don't have getpagesize in unistd.h. We don't use
1708 # AC_CHECK_FUNCS(getpagesize), because other environments rename getpagesize
1710 AC_CHECK_DECLS([getpagesize], , , [
1711 #ifdef HAVE_UNISTD_H
1715 # Allow user to specify an alternate syslog facility
1716 AC_ARG_WITH(syslog-facility,
1717 AS_HELP_STRING(--with-syslog-facility=LOG, [syslog facility to use (default=LOG_DAEMON)]),
1718 syslog_facility="$withval", syslog_facility="LOG_DAEMON")
1719 AC_DEFINE_UNQUOTED(LOGFACILITY,$syslog_facility,[name of the syslog facility])
1720 AC_SUBST(LOGFACILITY)
1722 # Check if we have getresuid and getresgid
1723 AC_CHECK_FUNCS(getresuid getresgid)
1725 # Check for gethostbyname_r in all its glorious incompatible versions.
1726 # (This logic is based on that in Python's configure.in)
1727 AH_TEMPLATE(HAVE_GETHOSTBYNAME_R,
1728 [Define this if you have any gethostbyname_r()])
1730 AC_CHECK_FUNC(gethostbyname_r, [
1731 AC_MSG_CHECKING([how many arguments gethostbyname_r() wants])
1733 CFLAGS="$CFLAGS $MY_CPPFLAGS $MY_THREAD_CPPFLAGS $MY_CFLAGS"
1734 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1738 struct hostent *h1, *h2;
1740 (void)gethostbyname_r(cp1,h1,cp2,i1,&h2,&i2);
1742 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1743 AC_DEFINE(HAVE_GETHOSTBYNAME_R_6_ARG, 1,
1744 [Define this if gethostbyname_r takes 6 arguments])
1747 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1753 (void)gethostbyname_r(cp1,h1,cp2,i1,&i2);
1755 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1756 AC_DEFINE(HAVE_GETHOSTBYNAME_R_5_ARG, 1,
1757 [Define this if gethostbyname_r takes 5 arguments])
1760 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1765 struct hostent_data hd;
1766 (void) gethostbyname_r(cp1,h1,&hd);
1768 AC_DEFINE(HAVE_GETHOSTBYNAME_R)
1769 AC_DEFINE(HAVE_GETHOSTBYNAME_R_3_ARG, 1,
1770 [Define this if gethostbyname_r takes 3 arguments])
1780 AC_CACHE_CHECK([whether the C compiler supports __func__],
1781 tor_cv_have_func_macro,
1782 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1784 int main(int c, char **v) { puts(__func__); }])],
1785 tor_cv_have_func_macro=yes,
1786 tor_cv_have_func_macro=no))
1788 AC_CACHE_CHECK([whether the C compiler supports __FUNC__],
1789 tor_cv_have_FUNC_macro,
1790 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1792 int main(int c, char **v) { puts(__FUNC__); }])],
1793 tor_cv_have_FUNC_macro=yes,
1794 tor_cv_have_FUNC_macro=no))
1796 AC_CACHE_CHECK([whether the C compiler supports __FUNCTION__],
1797 tor_cv_have_FUNCTION_macro,
1798 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1800 int main(int c, char **v) { puts(__FUNCTION__); }])],
1801 tor_cv_have_FUNCTION_macro=yes,
1802 tor_cv_have_FUNCTION_macro=no))
1804 AC_CACHE_CHECK([whether we have extern char **environ already declared],
1805 tor_cv_have_environ_declared,
1806 AC_COMPILE_IFELSE([AC_LANG_SOURCE([
1807 #ifdef HAVE_UNISTD_H
1811 int main(int c, char **v) { char **t = environ; }])],
1812 tor_cv_have_environ_declared=yes,
1813 tor_cv_have_environ_declared=no))
1815 if test "$tor_cv_have_func_macro" = "yes"; then
1816 AC_DEFINE(HAVE_MACRO__func__, 1, [Defined if the compiler supports __func__])
1819 if test "$tor_cv_have_FUNC_macro" = "yes"; then
1820 AC_DEFINE(HAVE_MACRO__FUNC__, 1, [Defined if the compiler supports __FUNC__])
1823 if test "$tor_cv_have_FUNCTION_macro" = "yes"; then
1824 AC_DEFINE(HAVE_MACRO__FUNCTION__, 1,
1825 [Defined if the compiler supports __FUNCTION__])
1828 if test "$tor_cv_have_environ_declared" = "yes"; then
1829 AC_DEFINE(HAVE_EXTERN_ENVIRON_DECLARED, 1,
1830 [Defined if we have extern char **environ already declared])
1833 # $prefix stores the value of the --prefix command line option, or
1834 # NONE if the option wasn't set. In the case that it wasn't set, make
1835 # it be the default, so that we can use it to expand directories now.
1836 if test "x$prefix" = "xNONE"; then
1837 prefix=$ac_default_prefix
1840 # and similarly for $exec_prefix
1841 if test "x$exec_prefix" = "xNONE"; then
1845 if test "x$BUILDDIR" = "x"; then
1849 AH_TEMPLATE([BUILDDIR],[tor's build directory])
1850 AC_DEFINE_UNQUOTED(BUILDDIR,"$BUILDDIR")
1852 if test "x$CONFDIR" = "x"; then
1853 CONFDIR=`eval echo $sysconfdir/tor`
1856 AH_TEMPLATE([CONFDIR],[tor's configuration directory])
1857 AC_DEFINE_UNQUOTED(CONFDIR,"$CONFDIR")
1859 BINDIR=`eval echo $bindir`
1861 LOCALSTATEDIR=`eval echo $localstatedir`
1862 AC_SUBST(LOCALSTATEDIR)
1864 if test "$bwin32" = "true"; then
1865 # Test if the linker supports the --nxcompat and --dynamicbase options
1867 save_LDFLAGS="$LDFLAGS"
1868 LDFLAGS="-Wl,--nxcompat -Wl,--dynamicbase"
1869 AC_MSG_CHECKING([whether the linker supports DllCharacteristics])
1870 AC_LINK_IFELSE([AC_LANG_PROGRAM([])],
1871 [AC_MSG_RESULT([yes])]
1872 [save_LDFLAGS="$save_LDFLAGS $LDFLAGS"],
1873 [AC_MSG_RESULT([no])]
1875 LDFLAGS="$save_LDFLAGS"
1878 # Set CFLAGS _after_ all the above checks, since our warnings are stricter
1879 # than autoconf's macros like.
1880 if test "$GCC" = "yes"; then
1881 # Disable GCC's strict aliasing checks. They are an hours-to-debug
1882 # accident waiting to happen.
1883 CFLAGS="$CFLAGS -Wall -fno-strict-aliasing"
1885 # Override optimization level for non-gcc compilers
1887 enable_gcc_warnings=no
1888 enable_gcc_warnings_advisory=no
1891 # Warnings implies advisory-warnings and -Werror.
1892 if test "$enable_gcc_warnings" = "yes"; then
1893 enable_gcc_warnings_advisory=yes
1894 enable_fatal_warnings=yes
1897 # OS X Lion started deprecating the system openssl. Let's just disable
1898 # all deprecation warnings on OS X. Also, to potentially make the binary
1899 # a little smaller, let's enable dead_strip.
1903 CFLAGS="$CFLAGS -Wno-deprecated-declarations"
1904 LDFLAGS="$LDFLAGS -dead_strip" ;;
1907 # Add some more warnings which we use in development but not in the
1908 # released versions. (Some relevant gcc versions can't handle these.)
1910 # Note that we have to do this near the end of the autoconf process, or
1911 # else we may run into problems when these warnings hit on the testing C
1912 # programs that autoconf wants to build.
1913 if test "x$enable_gcc_warnings_advisory" != "xno"; then
1916 *-*-openbsd* | *-*-bitrig*)
1917 # Some OpenBSD versions (like 4.8) have -Wsystem-headers by default.
1918 # That's fine, except that the headers don't pass -Wredundant-decls.
1919 # Therefore, let's disable -Wsystem-headers when we're building
1920 # with maximal warnings on OpenBSD.
1921 CFLAGS="$CFLAGS -Wno-system-headers" ;;
1924 # GCC4.3 users once report trouble with -Wstrict-overflow=5. GCC5 users
1925 # have it work better.
1926 # CFLAGS="$CFLAGS -Wstrict-overflow=1"
1928 # This warning was added in gcc 4.3, but it appears to generate
1929 # spurious warnings in gcc 4.4. I don't know if it works in 4.5.
1930 #CFLAGS="$CFLAGS -Wlogical-op"
1932 m4_foreach_w([warning_flag], [
1934 -Waddress-of-array-temporary
1935 -Waddress-of-temporary
1937 -Wanonymous-pack-parens
1940 -Warc-bridge-casts-disallowed-in-nonarc
1941 -Warc-maybe-repeated-use-of-weak
1942 -Warc-performSelector-leaks
1943 -Warc-repeated-use-of-weak
1945 -Warray-bounds-pointer-arithmetic
1947 -Wasm-operand-widths
1949 -Watomic-property-with-user-defined-accessor
1951 -Wauto-storage-class
1954 -Wbackslash-newline-escape
1955 -Wbad-array-new-length
1956 -Wbind-to-temporary-copy
1957 -Wbitfield-constant-conversion
1960 -Wbuiltin-requires-header
1962 -Wcompare-distinct-pointer-types
1963 -Wcomplex-component-init
1964 -Wconditional-type-mismatch
1966 -Wconstant-conversion
1967 -Wconstant-logical-operand
1968 -Wconstexpr-not-const
1969 -Wcustom-atomic-properties
1971 -Wdangling-initializer-list
1973 -Wdelegating-ctor-cycles
1974 -Wdeprecated-implementations
1975 -Wdeprecated-register
1976 -Wdirect-ivar-access
1978 -Wdistributed-object-modifiers
1980 -Wdollar-in-identifier-extension
1982 -Wduplicate-decl-specifier
1984 -Wduplicate-method-arg
1985 -Wduplicate-method-match
1987 -Wdynamic-class-memaccess
1988 -Wembedded-directive
1989 -Wempty-translation-unit
1991 -Wexit-time-destructors
1992 -Wexplicit-ownership-type
1993 -Wextern-initializer
1997 -Wflexible-array-extensions
2000 -Wfour-char-constants
2002 -Wglobal-constructors
2003 -Wgnu-array-member-paren-init
2005 -Wgnu-static-float-init
2008 -Widiomatic-parentheses
2009 -Wignored-attributes
2010 -Wimplicit-atomic-properties
2011 -Wimplicit-conversion-floating-point-to-bool
2012 -Wimplicit-exception-spec-mismatch
2013 -Wimplicit-fallthrough
2014 -Wimplicit-fallthrough-per-function
2015 -Wimplicit-retain-self
2016 -Wimport-preprocessor-directive-pedantic
2017 -Wincompatible-library-redeclaration
2018 -Wincompatible-pointer-types-discards-qualifiers
2019 -Wincomplete-implementation
2021 -Wincomplete-umbrella
2024 -Wint-to-void-pointer-cast
2030 -Winvalid-source-encoding
2031 -Winvalid-token-paste
2032 -Wknr-promoted-parameter
2033 -Wlarge-by-value-copy
2034 -Wliteral-conversion
2036 -Wlocal-type-template-args
2040 -Wmalformed-warning-check
2044 -Wmismatched-parameter-types
2045 -Wmismatched-return-types
2046 -Wmissing-field-initializers
2047 -Wmissing-format-attribute
2049 -Wmissing-selector-name
2051 -Wmissing-variable-declarations
2055 -Wnon-literal-null-conversion
2057 -Wnonportable-cfstrings
2063 -Wout-of-line-declaration
2065 -Woverlength-strings
2067 -Woverriding-method-mismatch
2068 -Wpointer-type-mismatch
2069 -Wpredefined-identifier-outside-function
2070 -Wprotocol-property-synthesis-ambiguity
2071 -Wreadonly-iboutlet-property
2072 -Wreadonly-setter-attrs
2074 -Wreceiver-forward-class
2076 -Wreinterpret-base-class
2077 -Wrequires-super-attribute
2078 -Wreserved-user-defined-literal
2079 -Wreturn-stack-address
2081 -Wselector-type-mismatch
2083 -Wserialized-diagnostics
2085 -Wshift-count-negative
2086 -Wshift-count-overflow
2087 -Wshift-negative-value
2089 -Wshift-sign-overflow
2091 -Wsizeof-array-argument
2092 -Wsource-uses-openmp
2095 -Wstatic-local-in-inline
2099 -Wstrlcpy-strlcat-size
2101 -Wsuggest-attribute=format
2102 -Wsuggest-attribute=noreturn
2103 -Wsuper-class-method-mismatch
2106 -Wtautological-constant-out-of-range-compare
2107 -Wtentative-definition-incomplete-type
2110 -Wtypedef-redefinition
2113 -Wundefined-internal
2114 -Wundefined-reinterpret-cast
2116 -Wunicode-whitespace
2117 -Wunknown-warning-option
2118 -Wunnamed-type-template-args
2119 -Wunneeded-member-function
2121 -Wunsupported-visibility
2122 -Wunused-but-set-parameter
2123 -Wunused-but-set-variable
2124 -Wunused-command-line-argument
2125 -Wunused-const-variable=2
2126 -Wunused-exception-parameter
2127 -Wunused-local-typedefs
2128 -Wunused-member-function
2129 -Wunused-sanitize-argument
2130 -Wunused-volatile-lvalue
2131 -Wuser-defined-literals
2134 -Wvector-conversions
2139 ], [ TOR_CHECK_CFLAGS([warning_flag]) ])
2141 dnl We should re-enable this in some later version. Clang doesn't
2142 dnl mind, but it causes trouble with GCC.
2143 dnl -Wstrict-overflow=2
2145 dnl These seem to require annotations that we don't currently use,
2146 dnl and they give false positives in our pthreads wrappers. (Clang 4)
2148 dnl -Wthread-safety-analysis
2149 dnl -Wthread-safety-attributes
2150 dnl -Wthread-safety-beta
2151 dnl -Wthread-safety-precise
2153 CFLAGS="$CFLAGS -W -Wfloat-equal -Wundef -Wpointer-arith"
2154 CFLAGS="$CFLAGS -Wstrict-prototypes -Wmissing-prototypes -Wwrite-strings"
2155 CFLAGS="$CFLAGS -Wredundant-decls -Wchar-subscripts -Wcomment -Wformat=2"
2156 CFLAGS="$CFLAGS -Wwrite-strings"
2157 CFLAGS="$CFLAGS -Wnested-externs -Wbad-function-cast -Wswitch-enum"
2158 CFLAGS="$CFLAGS -Waggregate-return -Wpacked -Wunused"
2159 CFLAGS="$CFLAGS -Wunused-parameter "
2160 # These interfere with building main() { return 0; }, which autoconf
2161 # likes to use as its default program.
2162 CFLAGS="$CFLAGS -Wold-style-definition -Wmissing-declarations"
2164 if test "$tor_cv_cflags__Wnull_dereference" = "yes"; then
2165 AC_DEFINE([HAVE_CFLAG_WNULL_DEREFERENCE], 1, [True if we have -Wnull-dereference])
2167 if test "$tor_cv_cflags__Woverlength_strings" = "yes"; then
2168 AC_DEFINE([HAVE_CFLAG_WOVERLENGTH_STRINGS], 1, [True if we have -Woverlength-strings])
2171 if test "x$enable_fatal_warnings" = "xyes"; then
2172 # I'd like to use TOR_CHECK_CFLAGS here, but I can't, since the
2173 # default autoconf programs are full of errors.
2174 CFLAGS="$CFLAGS -Werror"
2179 if test "$enable_coverage" = "yes" && test "$have_clang" = "no"; then
2182 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.])
2186 CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent $TOR_CPPFLAGS_openssl $TOR_CPPFLAGS_zlib"
2191 contrib/dist/suse/tor.sh
2192 contrib/operator-tools/tor.logrotate
2195 contrib/dist/tor.service
2196 src/config/torrc.sample
2197 src/config/torrc.minimal
2198 src/rust/.cargo/config
2199 scripts/maint/checkOptionDocs.pl
2200 scripts/maint/updateVersions.pl
2203 if test "x$asciidoc" = "xtrue" && test "$ASCIIDOC" = "none"; then
2204 regular_mans="doc/tor doc/tor-gencert doc/tor-resolve doc/torify"
2205 for file in $regular_mans ; do
2206 if ! [[ -f "$srcdir/$file.1.in" ]] || ! [[ -f "$srcdir/$file.html.in" ]] ; then
2207 echo "==================================";
2209 echo "Building Tor has failed since manpages cannot be built.";
2211 echo "You need asciidoc installed to be able to build the manpages.";
2212 echo "To build without manpages, use the --disable-asciidoc argument";
2213 echo "when calling configure.";
2215 echo "==================================";
2221 if test "$fragile_hardening" = "yes"; then
2225 Warning! Building Tor with --enable-fragile-hardening (also known as
2226 --enable-expensive-hardening) makes some kinds of attacks harder, but makes
2227 other kinds of attacks easier. A Tor instance build with this option will be
2228 somewhat less vulnerable to remote code execution, arithmetic overflow, or
2229 out-of-bounds read/writes... but at the cost of becoming more vulnerable to
2230 denial of service attacks. For more information, see
2231 https://trac.torproject.org/projects/tor/wiki/doc/TorFragileHardening