nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-24 12:23:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'sebastian/libevent2'

Browse Source
This commit is contained in:
Nick Mathewson 2016-07-08 09:57:31 -04:00
commit 466259eb50
28 changed files with 44 additions and 4448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -176,7 +176,7 @@ coverage-html-full: all
genhtml --branch-coverage -o "$(HTML_COVER_DIR)" "$(HTML_COVER_DIR)/lcov.info" genhtml --branch-coverage -o "$(HTML_COVER_DIR)" "$(HTML_COVER_DIR)/lcov.info"
# Avoid strlcpy.c, strlcat.c, aes.c, OpenBSD_malloc_Linux.c, sha256.c, # Avoid strlcpy.c, strlcat.c, aes.c, OpenBSD_malloc_Linux.c, sha256.c,
# eventdns.[hc], tinytest*.[ch] # tinytest*.[ch]
check-spaces: check-spaces:
$(top_srcdir)/scripts/maint/checkSpace.pl -C \ $(top_srcdir)/scripts/maint/checkSpace.pl -C \
$(top_srcdir)/src/common/*.[ch] \ $(top_srcdir)/src/common/*.[ch] \

4
changes/bug19554 Normal file
View File

@ -0,0 +1,4 @@
o Dependency changes (Libevent)
- Tor requires Libevent version 2.0.10-stable or later now.
Implements ticket 19554.

51
configure.ac
View File

@ -481,7 +481,7 @@ TOR_SEARCH_LIBRARY(libevent, $trylibeventdir, [-levent $STATIC_LIBEVENT_FLAGS $T
#endif #endif
#include <sys/time.h> #include <sys/time.h>
#include <sys/types.h> #include <sys/types.h>
#include <event.h>], [ #include <event2/event.h>], [
#ifdef _WIN32 #ifdef _WIN32
#include <winsock2.h> #include <winsock2.h>
#endif #endif
@ -500,21 +500,10 @@ save_CPPFLAGS="$CPPFLAGS"
LIBS="-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $LIBS" LIBS="-levent $STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $LIBS"
LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS" LDFLAGS="$TOR_LDFLAGS_libevent $LDFLAGS"
CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS" CPPFLAGS="$TOR_CPPFLAGS_libevent $CPPFLAGS"
AC_CHECK_FUNCS([event_get_version_number \ AC_CHECK_FUNCS([evutil_secure_rng_set_urandom_device_file])
evutil_secure_rng_set_urandom_device_file \
evutil_secure_rng_init \
])
AC_CHECK_MEMBERS([struct event.min_heap_idx], , ,
[#include <event.h>
])
AC_CHECK_HEADERS(event2/event.h event2/dns.h event2/bufferevent_ssl.h)
LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS" LIBS="$STATIC_LIBEVENT_FLAGS $TOR_LIB_WS32 $save_LIBS"
AM_CONDITIONAL(USE_EXTERNAL_EVDNS,
test "x$ac_cv_header_event2_dns_h" = "xyes")
if test "$enable_static_libevent" = "yes"; then if test "$enable_static_libevent" = "yes"; then
if test "$tor_cv_library_libevent_dir" = "(system)"; then if test "$tor_cv_library_libevent_dir" = "(system)"; then
AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent") AC_MSG_ERROR("You must specify an explicit --with-libevent-dir=x option when using --enable-static-libevent")
@ -541,30 +530,32 @@ LIBS="$save_LIBS"
LDFLAGS="$save_LDFLAGS" LDFLAGS="$save_LDFLAGS"
CPPFLAGS="$save_CPPFLAGS" CPPFLAGS="$save_CPPFLAGS"
dnl This isn't the best test for Libevent 2.0.3-alpha. Once it's released, dnl Check that libevent is at least at version 2.0.10, the first stable
dnl we can do much better. dnl release of its series
if test "$enable_bufferevents" = "yes"; then
if test "$ac_cv_header_event2_bufferevent_ssl_h" != "yes"; then
AC_MSG_ERROR([You've asked for bufferevent support, but you're using a version of Libevent without SSL support. This won't work. We need Libevent 2.0.8-rc or later, and you don't seem to even have Libevent 2.0.3-alpha.])
else
CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent" CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
AC_MSG_CHECKING([whether Libevent is new enough])
# Check for the right version. First see if version detection works.
AC_MSG_CHECKING([whether we can detect the Libevent version])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([ AC_COMPILE_IFELSE([AC_LANG_SOURCE([
#include <event2/event.h> #include <event2/event.h>
#if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 10 #if !defined(LIBEVENT_VERSION_NUMBER) || LIBEVENT_VERSION_NUMBER < 0x02000a00
#error #error
int x = y(zz); int x = y(zz);
#else #else
int x = 1; int x = 1;
#endif #endif
])], [event_version_number_works=yes; AC_MSG_RESULT([yes]) ], ])], [ AC_MSG_RESULT([yes]) ],
[event_version_number_works=no; AC_MSG_RESULT([no])]) [ AC_MSG_RESULT([no])
if test "$event_version_number_works" != "yes"; then AC_MSG_ERROR([Libevent is not new enough. We require 2.0.10-stable or later]) ] )
AC_MSG_WARN([Version detection on Libevent seems broken. Your Libevent installation is probably screwed up or very old.])
else LIBS="$save_LIBS"
LDFLAGS="$save_LDFLAGS"
CPPFLAGS="$save_CPPFLAGS"
dnl bufferents require version 2.0.13
if test "$enable_bufferevents" = "yes"; then
AC_CHECK_HEADERS(event2/bufferevent_ssl.h)
CPPFLAGS="$CPPFLAGS $TOR_CPPFLAGS_libevent"
AC_MSG_CHECKING([whether Libevent is new enough for bufferevents]) AC_MSG_CHECKING([whether Libevent is new enough for bufferevents])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([ AC_COMPILE_IFELSE([AC_LANG_SOURCE([
#include <event2/event.h> #include <event2/event.h>
@ -578,8 +569,6 @@ int x = 1;
[ AC_MSG_RESULT([no]) [ AC_MSG_RESULT([no])
AC_MSG_ERROR([Libevent does not seem new enough to support bufferevents. We require 2.0.13-stable or later]) ] ) AC_MSG_ERROR([Libevent does not seem new enough to support bufferevents. We require 2.0.13-stable or later]) ] )
fi fi
fi
fi
LIBS="$save_LIBS" LIBS="$save_LIBS"
LDFLAGS="$save_LDFLAGS" LDFLAGS="$save_LDFLAGS"

2
scripts/maint/redox.py
View File

@ -33,8 +33,6 @@
# files that we've snarfed in from somebody else, whose C we do no intend # files that we've snarfed in from somebody else, whose C we do no intend
# to document for them. # to document for them.
SKIP_FILES = [ "OpenBSD_malloc_Linux.c", SKIP_FILES = [ "OpenBSD_malloc_Linux.c",
"eventdns.c",
"eventdns.h",
"strlcat.c", "strlcat.c",
"strlcpy.c", "strlcpy.c",
"sha256.c", "sha256.c",

222
src/common/compat_libevent.c
View File

@ -3,11 +3,8 @@
/** /**
* \file compat_libevent.c * \file compat_libevent.c
* \brief Wrappers to handle porting between different versions of libevent. * \brief Wrappers and utility functions for Libevent.
* */
* In an ideal world, we'd just use Libevent 2.0 from now on. But as of June
* 2012, Libevent 1.4 is still all over, and some poor souls are stuck on
* Libevent 1.3e. */
#include "orconfig.h" #include "orconfig.h"
#include "compat.h" #include "compat.h"
@ -19,15 +16,11 @@
#include "util.h" #include "util.h"
#include "torlog.h" #include "torlog.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#include <event2/thread.h> #include <event2/thread.h>
#ifdef USE_BUFFEREVENTS #ifdef USE_BUFFEREVENTS
#include <event2/bufferevent.h> #include <event2/bufferevent.h>
#endif #endif
#else
#include <event.h>
#endif
/** A string which, if it appears in a libevent log, should be ignored. */ /** A string which, if it appears in a libevent log, should be ignored. */
static const char *suppress_msg = NULL; static const char *suppress_msg = NULL;
@ -69,6 +62,7 @@ configure_libevent_logging(void)
{ {
event_set_log_callback(libevent_logging_callback); event_set_log_callback(libevent_logging_callback);
} }
/** Ignore any libevent log message that contains <b>msg</b>. */ /** Ignore any libevent log message that contains <b>msg</b>. */
void void
suppress_libevent_log_msg(const char *msg) suppress_libevent_log_msg(const char *msg)
@ -76,44 +70,6 @@ suppress_libevent_log_msg(const char *msg)
suppress_msg = msg; suppress_msg = msg;
} }
#ifndef HAVE_EVENT2_EVENT_H
/** Work-alike replacement for event_new() on pre-Libevent-2.0 systems. */
struct event *
tor_event_new(struct event_base *base, int sock, short what,
void (*cb)(int, short, void *), void *arg)
{
struct event *e = tor_malloc_zero(sizeof(struct event));
event_set(e, sock, what, cb, arg);
if (! base)
base = tor_libevent_get_base();
event_base_set(base, e);
return e;
}
/** Work-alike replacement for evtimer_new() on pre-Libevent-2.0 systems. */
struct event *
tor_evtimer_new(struct event_base *base,
void (*cb)(int, short, void *), void *arg)
{
return tor_event_new(base, -1, 0, cb, arg);
}
/** Work-alike replacement for evsignal_new() on pre-Libevent-2.0 systems. */
struct event *
tor_evsignal_new(struct event_base * base, int sig,
void (*cb)(int, short, void *), void *arg)
{
return tor_event_new(base, sig, EV_SIGNAL|EV_PERSIST, cb, arg);
}
/** Work-alike replacement for event_free() on pre-Libevent-2.0 systems,
* except tolerate tor_event_free(NULL). */
void
tor_event_free(struct event *ev)
{
if (ev == NULL)
return;
event_del(ev);
tor_free(ev);
}
#else
/* Wrapper for event_free() that tolerates tor_event_free(NULL) */ /* Wrapper for event_free() that tolerates tor_event_free(NULL) */
void void
tor_event_free(struct event *ev) tor_event_free(struct event *ev)
@ -122,7 +78,6 @@ tor_event_free(struct event *ev)
return; return;
event_free(ev); event_free(ev);
} }
#endif
/** Global event base for use by the main thread. */ /** Global event base for use by the main thread. */
static struct event_base *the_event_base = NULL; static struct event_base *the_event_base = NULL;
@ -158,7 +113,6 @@ tor_libevent_initialize(tor_libevent_cfg *torcfg)
/* some paths below don't use torcfg, so avoid unused variable warnings */ /* some paths below don't use torcfg, so avoid unused variable warnings */
(void)torcfg; (void)torcfg;
#ifdef HAVE_EVENT2_EVENT_H
{ {
int attempts = 0; int attempts = 0;
int using_threads; int using_threads;
@ -190,16 +144,12 @@ tor_libevent_initialize(tor_libevent_cfg *torcfg)
event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK); event_config_set_flag(cfg, EVENT_BASE_FLAG_NOLOCK);
} }
#if defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER >= V(2,0,7)
if (torcfg->num_cpus > 0) if (torcfg->num_cpus > 0)
event_config_set_num_cpus_hint(cfg, torcfg->num_cpus); event_config_set_num_cpus_hint(cfg, torcfg->num_cpus);
#endif
#if LIBEVENT_VERSION_NUMBER >= V(2,0,9)
/* We can enable changelist support with epoll, since we don't give /* We can enable changelist support with epoll, since we don't give
* Libevent any dup'd fds. This lets us avoid some syscalls. */ * Libevent any dup'd fds. This lets us avoid some syscalls. */
event_config_set_flag(cfg, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST); event_config_set_flag(cfg, EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST);
#endif
the_event_base = event_base_new_with_config(cfg); the_event_base = event_base_new_with_config(cfg);
@ -223,9 +173,6 @@ tor_libevent_initialize(tor_libevent_cfg *torcfg)
goto retry; goto retry;
} }
} }
#else
the_event_base = event_init();
#endif
if (!the_event_base) { if (!the_event_base) {
/* LCOV_EXCL_START */ /* LCOV_EXCL_START */
@ -234,8 +181,6 @@ tor_libevent_initialize(tor_libevent_cfg *torcfg)
/* LCOV_EXCL_STOP */ /* LCOV_EXCL_STOP */
} }
/* Making this a NOTICE for now so we can link bugs to a libevent versions
* or methods better. */
log_info(LD_GENERAL, log_info(LD_GENERAL,
"Initialized libevent version %s using method %s. Good.", "Initialized libevent version %s using method %s. Good.",
event_get_version(), tor_libevent_get_method()); event_get_version(), tor_libevent_get_method());
@ -257,62 +202,7 @@ tor_libevent_get_base, (void))
const char * const char *
tor_libevent_get_method(void) tor_libevent_get_method(void)
{ {
#ifdef HAVE_EVENT2_EVENT_H
return event_base_get_method(the_event_base); return event_base_get_method(the_event_base);
#else
return event_get_method();
#endif
}
/** Return the le_version_t for the version of libevent specified in the
* string <b>v</b>. If the version is very new or uses an unrecognized
* version, format, return LE_OTHER. */
STATIC le_version_t
tor_decode_libevent_version(const char *v)
{
unsigned major, minor, patchlevel;
char c, e, extra;
int fields;
/* Try the new preferred "1.4.11-stable" format.
* Also accept "1.4.14b-stable". */
fields = tor_sscanf(v, "%u.%u.%u%c%c", &major, &minor, &patchlevel, &c, &e);
if (fields == 3 ||
((fields == 4 || fields == 5 ) && (c == '-' || c == '_')) ||
(fields == 5 && TOR_ISALPHA(c) && (e == '-' || e == '_'))) {
return V(major,minor,patchlevel);
}
/* Try the old "1.3e" format. */
fields = tor_sscanf(v, "%u.%u%c%c", &major, &minor, &c, &extra);
if (fields == 3 && TOR_ISALPHA(c)) {
return V_OLD(major, minor, c);
} else if (fields == 2) {
return V(major, minor, 0);
}
return LE_OTHER;
}
/** Return an integer representing the binary interface of a Libevent library.
* Two different versions with different numbers are sure not to be binary
* compatible. Two different versions with the same numbers have a decent
* chance of binary compatibility.*/
STATIC int
le_versions_compatibility(le_version_t v)
{
if (v == LE_OTHER)
return 0;
if (v < V_OLD(1,0,'c'))
return 1;
else if (v < V(1,4,0))
return 2;
else if (v < V(1,4,99))
return 3;
else if (v < V(2,0,1))
return 4;
else /* Everything 2.0 and later should be compatible. */
return 5;
} }
/** Return a string representation of the version of the currently running /** Return a string representation of the version of the currently running
@ -323,101 +213,14 @@ tor_libevent_get_version_str(void)
return event_get_version(); return event_get_version();
} }
#if defined(LIBEVENT_VERSION)
#define HEADER_VERSION LIBEVENT_VERSION
#elif defined(_EVENT_VERSION)
#define HEADER_VERSION _EVENT_VERSION
#endif
/** Return a string representation of the version of Libevent that was used /** Return a string representation of the version of Libevent that was used
* at compilation time. */ * at compilation time. */
const char * const char *
tor_libevent_get_header_version_str(void) tor_libevent_get_header_version_str(void)
{ {
return HEADER_VERSION; return LIBEVENT_VERSION;
} }
/** See whether the headers we were built against differ from the library we
* linked against so much that we're likely to crash. If so, warn the
* user. */
void
tor_check_libevent_header_compatibility(void)
{
(void) le_versions_compatibility;
(void) tor_decode_libevent_version;
/* In libevent versions before 2.0, it's hard to keep binary compatibility
* between upgrades, and unpleasant to detect when the version we compiled
* against is unlike the version we have linked against. Here's how. */
#if defined(HEADER_VERSION)
/* We have a header-file version and a function-call version. Easy. */
if (strcmp(HEADER_VERSION, event_get_version())) {
le_version_t v1, v2;
int compat1 = -1, compat2 = -1;
int verybad;
v1 = tor_decode_libevent_version(HEADER_VERSION);
v2 = tor_decode_libevent_version(event_get_version());
compat1 = le_versions_compatibility(v1);
compat2 = le_versions_compatibility(v2);
verybad = compat1 != compat2;
tor_log(verybad ? LOG_WARN : LOG_NOTICE,
LD_GENERAL, "We were compiled with headers from version %s "
"of Libevent, but we're using a Libevent library that says it's "
"version %s.", HEADER_VERSION, event_get_version());
if (verybad)
log_warn(LD_GENERAL, "This will almost certainly make Tor crash.");
else
log_info(LD_GENERAL, "I think these versions are binary-compatible.");
}
#else
/* event_get_version but no _EVENT_VERSION. We might be in 1.4.0-beta or
earlier, where that's normal. To see whether we were compiled with an
earlier version, let's see whether the struct event defines MIN_HEAP_IDX.
*/
#ifdef HAVE_STRUCT_EVENT_MIN_HEAP_IDX
/* The header files are 1.4.0-beta or later. If the version is not
* 1.4.0-beta, we are incompatible. */
{
if (strcmp(event_get_version(), "1.4.0-beta")) {
log_warn(LD_GENERAL, "It's a little hard to tell, but you seem to have "
"Libevent 1.4.0-beta header files, whereas you have linked "
"against Libevent %s. This will probably make Tor crash.",
event_get_version());
}
}
#else
/* Our headers are 1.3e or earlier. If the library version is not 1.4.x or
later, we're probably fine. */
{
const char *v = event_get_version();
if ((v[0] == '1' && v[2] == '.' && v[3] > '3') || v[0] > '1') {
log_warn(LD_GENERAL, "It's a little hard to tell, but you seem to have "
"Libevent header file from 1.3e or earlier, whereas you have "
"linked against Libevent %s. This will probably make Tor "
"crash.", event_get_version());
}
}
#endif
/* Your libevent is ancient. */
#endif
}
/*
If possible, we're going to try to use Libevent's periodic timer support,
since it does a pretty good job of making sure that periodic events get
called exactly M seconds apart, rather than starting each one exactly M
seconds after the time that the last one was run.
*/
#ifdef HAVE_EVENT2_EVENT_H
#define HAVE_PERIODIC
#define PERIODIC_FLAGS EV_PERSIST
#else
#define PERIODIC_FLAGS 0
#endif
/** Represents a timer that's run every N microseconds by Libevent. */ /** Represents a timer that's run every N microseconds by Libevent. */
struct periodic_timer_t { struct periodic_timer_t {
/** Underlying event used to implement this periodic event. */ /** Underlying event used to implement this periodic event. */
@ -426,11 +229,6 @@ struct periodic_timer_t {
void (*cb)(struct periodic_timer_t *, void *); void (*cb)(struct periodic_timer_t *, void *);
/** User-supplied data for the callback */ /** User-supplied data for the callback */
void *data; void *data;
#ifndef HAVE_PERIODIC
/** If Libevent doesn't know how to invoke events every N microseconds,
* we'll need to remember the timeout interval here. */
struct timeval tv;
#endif
}; };
/** Libevent callback to implement a periodic event. */ /** Libevent callback to implement a periodic event. */
@ -440,10 +238,6 @@ periodic_timer_cb(evutil_socket_t fd, short what, void *arg)
periodic_timer_t *timer = arg; periodic_timer_t *timer = arg;
(void) what; (void) what;
(void) fd; (void) fd;
#ifndef HAVE_PERIODIC
/** reschedule the event as needed. */
event_add(timer->ev, &timer->tv);
#endif
timer->cb(timer, timer->data); timer->cb(timer, timer->data);
} }
@ -461,16 +255,13 @@ periodic_timer_new(struct event_base *base,
tor_assert(tv); tor_assert(tv);
tor_assert(cb); tor_assert(cb);
timer = tor_malloc_zero(sizeof(periodic_timer_t)); timer = tor_malloc_zero(sizeof(periodic_timer_t));
if (!(timer->ev = tor_event_new(base, -1, PERIODIC_FLAGS, if (!(timer->ev = tor_event_new(base, -1, EV_PERSIST,
periodic_timer_cb, timer))) { periodic_timer_cb, timer))) {
tor_free(timer); tor_free(timer);
return NULL; return NULL;
} }
timer->cb = cb; timer->cb = cb;
timer->data = data; timer->data = data;
#ifndef HAVE_PERIODIC
memcpy(&timer->tv, tv, sizeof(struct timeval));
#endif
event_add(timer->ev, (struct timeval *)tv); /*drop const for old libevent*/ event_add(timer->ev, (struct timeval *)tv); /*drop const for old libevent*/
return timer; return timer;
} }
@ -541,16 +332,13 @@ int
tor_init_libevent_rng(void) tor_init_libevent_rng(void)
{ {
int rv = 0; int rv = 0;
#ifdef HAVE_EVUTIL_SECURE_RNG_INIT
char buf[256]; char buf[256];
if (evutil_secure_rng_init() < 0) { if (evutil_secure_rng_init() < 0) {
rv = -1; rv = -1;
} }
/* Older libevent -- manually initialize the RNG */
crypto_rand(buf, 32); crypto_rand(buf, 32);
evutil_secure_rng_add_bytes(buf, 32); evutil_secure_rng_add_bytes(buf, 32);
evutil_secure_rng_get_bytes(buf, sizeof(buf)); evutil_secure_rng_get_bytes(buf, sizeof(buf));
#endif
return rv; return rv;
} }

55
src/common/compat_libevent.h
View File

@ -7,40 +7,21 @@
#include "orconfig.h" #include "orconfig.h"
#include "testsupport.h" #include "testsupport.h"
struct event; #include <event2/event.h>
struct event_base;
#ifdef USE_BUFFEREVENTS
struct bufferevent;
struct ev_token_bucket_cfg;
struct bufferevent_rate_limit_group;
#endif
#ifdef HAVE_EVENT2_EVENT_H #ifdef USE_BUFFEREVENTS
#include <event2/util.h> #include <event2/bufferevent.h>
#elif !defined(EVUTIL_SOCKET_DEFINED)
#define EVUTIL_SOCKET_DEFINED
#define evutil_socket_t int
#endif #endif
void configure_libevent_logging(void); void configure_libevent_logging(void);
void suppress_libevent_log_msg(const char *msg); void suppress_libevent_log_msg(const char *msg);
#ifdef HAVE_EVENT2_EVENT_H
#define tor_event_new event_new #define tor_event_new event_new
#define tor_evtimer_new evtimer_new #define tor_evtimer_new evtimer_new
#define tor_evsignal_new evsignal_new #define tor_evsignal_new evsignal_new
#define tor_evdns_add_server_port(sock, tcp, cb, data) \ #define tor_evdns_add_server_port(sock, tcp, cb, data) \
evdns_add_server_port_with_base(tor_libevent_get_base(), \ evdns_add_server_port_with_base(tor_libevent_get_base(), \
(sock),(tcp),(cb),(data)); (sock),(tcp),(cb),(data));
#else
struct event *tor_event_new(struct event_base * base, evutil_socket_t sock,
short what, void (*cb)(evutil_socket_t, short, void *), void *arg);
struct event *tor_evtimer_new(struct event_base * base,
void (*cb)(evutil_socket_t, short, void *), void *arg);
struct event *tor_evsignal_new(struct event_base * base, int sig,
void (*cb)(evutil_socket_t, short, void *), void *arg);
#define tor_evdns_add_server_port evdns_add_server_port
#endif
void tor_event_free(struct event *ev); void tor_event_free(struct event *ev);
@ -92,40 +73,18 @@ void tor_gettimeofday_cache_set(const struct timeval *tv);
void tor_gettimeofday_cached_monotonic(struct timeval *tv); void tor_gettimeofday_cached_monotonic(struct timeval *tv);
#ifdef COMPAT_LIBEVENT_PRIVATE #ifdef COMPAT_LIBEVENT_PRIVATE
/** A number representing a version of Libevent.
This is a 4-byte number, with the first three bytes representing the /** Macro: returns the number of a Libevent version as a 4-byte number,
major, minor, and patchlevel respectively of the library. The fourth with the first three bytes representing the major, minor, and patchlevel
byte is unused. respectively of the library. The fourth byte is unused.
This is equivalent to the format of LIBEVENT_VERSION_NUMBER on Libevent This is equivalent to the format of LIBEVENT_VERSION_NUMBER on Libevent
2.0.1 or later. For versions of Libevent before 1.4.0, which followed the 2.0.1 or later. */
format of "1.0, 1.0a, 1.0b", we define 1.0 to be equivalent to 1.0.0, 1.0a
to be equivalent to 1.0.1, and so on.
*/
typedef uint32_t le_version_t;
/** @{ */
/** Macros: returns the number of a libevent version as a le_version_t */
#define V(major, minor, patch) \ #define V(major, minor, patch) \
(((major) << 24) | ((minor) << 16) | ((patch) << 8)) (((major) << 24) | ((minor) << 16) | ((patch) << 8))
#define V_OLD(major, minor, patch) \
V((major), (minor), (patch)-'a'+1)
/** @} */
/** Represetns a version of libevent so old we can't figure out what version
* it is. */
#define LE_OLD V(0,0,0)
/** Represents a version of libevent so weird we can't figure out what version
* it is. */
#define LE_OTHER V(0,0,99)
STATIC void STATIC void
libevent_logging_callback(int severity, const char *msg); libevent_logging_callback(int severity, const char *msg);
STATIC le_version_t
tor_decode_libevent_version(const char *v);
STATIC int
le_versions_compatibility(le_version_t v);
#endif #endif
#endif #endif

18
src/common/procmon.c
View File

@ -10,11 +10,7 @@
#include "util.h" #include "util.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#ifdef HAVE_SIGNAL_H #ifdef HAVE_SIGNAL_H
#include <signal.h> #include <signal.h>
@ -164,18 +160,10 @@ tor_validate_process_specifier(const char *process_spec,
} }
/* XXXX we should use periodic_timer_new() for this stuff */ /* XXXX we should use periodic_timer_new() for this stuff */
#ifdef HAVE_EVENT2_EVENT_H
#define PERIODIC_TIMER_FLAGS EV_PERSIST #define PERIODIC_TIMER_FLAGS EV_PERSIST
#else
#define PERIODIC_TIMER_FLAGS (0)
#endif
/* DOCDOC poll_interval_tv */ /* DOCDOC poll_interval_tv */
static struct timeval poll_interval_tv = {15, 0}; static const struct timeval poll_interval_tv = {15, 0};
/* Note: If you port this file to plain Libevent 2, you can make
* poll_interval_tv const. It has to be non-const here because in
* libevent 1.x, event_add expects a pointer to a non-const struct
* timeval. */
/** Create a process-termination monitor for the process specifier /** Create a process-termination monitor for the process specifier
* given in <b>process_spec</b>. Return a newly allocated * given in <b>process_spec</b>. Return a newly allocated
@ -331,10 +319,6 @@ tor_process_monitor_poll_cb(evutil_socket_t unused1, short unused2,
if (its_dead_jim) { if (its_dead_jim) {
procmon->cb(procmon->cb_arg); procmon->cb(procmon->cb_arg);
#ifndef HAVE_EVENT2_EVENT_H
} else {
evtimer_add(procmon->e, &poll_interval_tv);
#endif
} }
} }
#endif #endif

4
src/common/timers.c
View File

@ -38,11 +38,7 @@
#include "torlog.h" #include "torlog.h"
#include "util.h" #include "util.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
struct timeout_cb { struct timeout_cb {
timer_cb_fn_t cb; timer_cb_fn_t cb;

7
src/ext/README
View File

@ -11,13 +11,6 @@ strlcpy.c
for strcat and strcpy. These are nonstandard, and some libc for strcat and strcpy. These are nonstandard, and some libc
implementations refuse to add them for religious reasons. implementations refuse to add them for religious reasons.
eventdns.[ch]
A fork of Libevent's DNS implementation, used by Tor when Libevent
2.0 or later is not available. Once Libevent 2.0 is required, we
should throw this away; it has diverged from evdns.[ch], and is
no longer easily mergeable.
ht.h ht.h
An implementation of a hash table in the style of Niels Provos's An implementation of a hash table in the style of Niels Provos's

3514
src/ext/eventdns.c
View File

File diff suppressed because it is too large Load Diff

337
src/ext/eventdns.h
View File

@ -1,337 +0,0 @@
/*
* The original DNS code is due to Adam Langley with heavy
* modifications by Nick Mathewson. Adam put his DNS software in the
* public domain. You can find his original copyright below. Please,
* aware that the code as part of libevent is governed by the 3-clause
* BSD license above.
*
* This software is Public Domain. To view a copy of the public domain dedication,
* visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
* Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
*
* I ask and expect, but do not require, that all derivative works contain an
* attribution similar to:
* Parts developed by Adam Langley <agl@imperialviolet.org>
*
* You may wish to replace the word "Parts" with something else depending on
* the amount of original code.
*
* (Derivative works does not include programs which link against, run or include
* the source verbatim in their source distributions)
*/
/*
* Welcome, gentle reader
*
* Async DNS lookups are really a whole lot harder than they should be,
* mostly stemming from the fact that the libc resolver has never been
* very good at them. Before you use this library you should see if libc
* can do the job for you with the modern async call getaddrinfo_a
* (see http://www.imperialviolet.org/page25.html#e498). Otherwise,
* please continue.
*
* This code is based on libevent and you must call event_init before
* any of the APIs in this file. You must also seed the OpenSSL random
* source if you are using OpenSSL for ids (see below).
*
* This library is designed to be included and shipped with your source
* code. You statically link with it. You should also test for the
* existence of strtok_r and define HAVE_STRTOK_R if you have it.
*
* The DNS protocol requires a good source of id numbers and these
* numbers should be unpredictable for spoofing reasons. There are
* three methods for generating them here and you must define exactly
* one of them. In increasing order of preference:
*
* DNS_USE_GETTIMEOFDAY_FOR_ID:
* Using the bottom 16 bits of the usec result from gettimeofday. This
* is a pretty poor solution but should work anywhere.
* DNS_USE_CPU_CLOCK_FOR_ID:
* Using the bottom 16 bits of the nsec result from the CPU's time
* counter. This is better, but may not work everywhere. Requires
* POSIX realtime support and you'll need to link against -lrt on
* glibc systems at least.
* DNS_USE_OPENSSL_FOR_ID:
* Uses the OpenSSL RAND_bytes call to generate the data. You must
* have seeded the pool before making any calls to this library.
*
* The library keeps track of the state of nameservers and will avoid
* them when they go down. Otherwise it will round robin between them.
*
* Quick start guide:
* #include "evdns.h"
* void callback(int result, char type, int count, int ttl,
* void *addresses, void *arg);
* evdns_resolv_conf_parse(DNS_OPTIONS_ALL, "/etc/resolv.conf");
* evdns_resolve("www.hostname.com", 0, callback, NULL);
*
* When the lookup is complete the callback function is called. The
* first argument will be one of the DNS_ERR_* defines in evdns.h.
* Hopefully it will be DNS_ERR_NONE, in which case type will be
* DNS_IPv4_A, count will be the number of IP addresses, ttl is the time
* which the data can be cached for (in seconds), addresses will point
* to an array of uint32_t's and arg will be whatever you passed to
* evdns_resolve.
*
* Searching:
*
* In order for this library to be a good replacement for glibc's resolver it
* supports searching. This involves setting a list of default domains, in
* which names will be queried for. The number of dots in the query name
* determines the order in which this list is used.
*
* Searching appears to be a single lookup from the point of view of the API,
* although many DNS queries may be generated from a single call to
* evdns_resolve. Searching can also drastically slow down the resolution
* of names.
*
* To disable searching:
* 1. Never set it up. If you never call evdns_resolv_conf_parse or
* evdns_search_add then no searching will occur.
*
* 2. If you do call evdns_resolv_conf_parse then don't pass
* DNS_OPTION_SEARCH (or DNS_OPTIONS_ALL, which implies it).
*
* 3. When calling evdns_resolve, pass the DNS_QUERY_NO_SEARCH flag.
*
* The order of searches depends on the number of dots in the name. If the
* number is greater than the ndots setting then the names is first tried
* globally. Otherwise each search domain is appended in turn.
*
* The ndots setting can either be set from a resolv.conf, or by calling
* evdns_search_ndots_set.
*
* For example, with ndots set to 1 (the default) and a search domain list of
* ["myhome.net"]:
* Query: www
* Order: www.myhome.net, www.
*
* Query: www.abc
* Order: www.abc., www.abc.myhome.net
*
* API reference:
*
* int evdns_nameserver_add(uint32_t address)
* Add a nameserver. The address should be an IP address in
* network byte order. The type of address is chosen so that
* it matches in_addr.s_addr.
* Returns non-zero on error.
*
* int evdns_nameserver_ip_add(const char *ip_as_string)
* This wraps the above function by parsing a string as an IP
* address and adds it as a nameserver.
* Returns non-zero on error
*
* int evdns_resolve(const char *name, int flags,
* evdns_callback_type callback,
* void *ptr)
* Resolve a name. The name parameter should be a DNS name.
* The flags parameter should be 0, or DNS_QUERY_NO_SEARCH
* which disables searching for this query. (see defn of
* searching above).
*
* The callback argument is a function which is called when
* this query completes and ptr is an argument which is passed
* to that callback function.
*
* Returns non-zero on error
*
* void evdns_search_clear()
* Clears the list of search domains
*
* void evdns_search_add(const char *domain)
* Add a domain to the list of search domains
*
* void evdns_search_ndots_set(int ndots)
* Set the number of dots which, when found in a name, causes
* the first query to be without any search domain.
*
* int evdns_count_nameservers(void)
* Return the number of configured nameservers (not necessarily the
* number of running nameservers). This is useful for double-checking
* whether our calls to the various nameserver configuration functions
* have been successful.
*
* int evdns_clear_nameservers_and_suspend(void)
* Remove all currently configured nameservers, and suspend all pending
* resolves. Resolves will not necessarily be re-attempted until
* evdns_resume() is called.
*
* int evdns_resume(void)
* Re-attempt resolves left in limbo after an earlier call to
* evdns_clear_nameservers_and_suspend().
*
* int evdns_config_windows_nameservers(void)
* Attempt to configure a set of nameservers based on platform settings on
* a win32 host. Preferentially tries to use GetNetworkParams; if that fails,
* looks in the registry. Returns 0 on success, nonzero on failure.
*
* int evdns_resolv_conf_parse(int flags, const char *filename)
* Parse a resolv.conf like file from the given filename.
*
* See the man page for resolv.conf for the format of this file.
* The flags argument determines what information is parsed from
* this file:
* DNS_OPTION_SEARCH - domain, search and ndots options
* DNS_OPTION_NAMESERVERS - nameserver lines
* DNS_OPTION_MISC - timeout and attempts options
* DNS_OPTIONS_ALL - all of the above
* The following directives are not parsed from the file:
* sortlist, rotate, no-check-names, inet6, debug
*
* Returns non-zero on error:
* 0 no errors
* 1 failed to open file
* 2 failed to stat file
* 3 file too large
* 4 out of memory
* 5 short read from file
* 6 no nameservers in file
*
* Internals:
*
* Requests are kept in two queues. The first is the inflight queue. In
* this queue requests have an allocated transaction id and nameserver.
* They will soon be transmitted if they haven't already been.
*
* The second is the waiting queue. The size of the inflight ring is
* limited and all other requests wait in waiting queue for space. This
* bounds the number of concurrent requests so that we don't flood the
* nameserver. Several algorithms require a full walk of the inflight
* queue and so bounding its size keeps thing going nicely under huge
* (many thousands of requests) loads.
*
* If a nameserver loses too many requests it is considered down and we
* try not to use it. After a while we send a probe to that nameserver
* (a lookup for google.com) and, if it replies, we consider it working
* again. If the nameserver fails a probe we wait longer to try again
* with the next probe.
*/
#ifndef TOR_EVENTDNS_H
#define TOR_EVENTDNS_H
/* Error codes 0-5 are as described in RFC 1035. */
#define DNS_ERR_NONE 0
/* The name server was unable to interpret the query */
#define DNS_ERR_FORMAT 1
/* The name server was unable to process this query due to a problem with the
* name server */
#define DNS_ERR_SERVERFAILED 2
/* The domain name does not exist */
#define DNS_ERR_NOTEXIST 3
/* The name server does not support the requested kind of query */
#define DNS_ERR_NOTIMPL 4
/* The name server refuses to reform the specified operation for policy
* reasons */
#define DNS_ERR_REFUSED 5
/* The reply was truncated or ill-formated */
#define DNS_ERR_TRUNCATED 65
/* An unknown error occurred */
#define DNS_ERR_UNKNOWN 66
/* Communication with the server timed out */
#define DNS_ERR_TIMEOUT 67
/* The request was canceled because the DNS subsystem was shut down. */
#define DNS_ERR_SHUTDOWN 68
#define DNS_IPv4_A 1
#define DNS_PTR 2
#define DNS_IPv6_AAAA 3
#define DNS_QUERY_NO_SEARCH 1
#define DNS_OPTION_SEARCH 1
#define DNS_OPTION_NAMESERVERS 2
#define DNS_OPTION_MISC 4
#define DNS_OPTIONS_ALL 7
/*
* The callback that contains the results from a lookup.
* - type is either DNS_IPv4_A or DNS_IPv6_AAAA or DNS_PTR
* - count contains the number of addresses of form type
* - ttl is the number of seconds the resolution may be cached for.
* - addresses needs to be cast according to type
*/
typedef void (*evdns_callback_type) (int result, char type, int count, int ttl, void *addresses, void *arg);
int evdns_init(void);
void evdns_shutdown(int fail_requests);
const char *evdns_err_to_string(int err);
int evdns_nameserver_add(uint32_t address);
int evdns_count_nameservers(void);
int evdns_clear_nameservers_and_suspend(void);
int evdns_resume(void);
int evdns_nameserver_ip_add(const char *ip_as_string);
int evdns_nameserver_sockaddr_add(const struct sockaddr *sa, socklen_t len);
void evdns_set_default_outgoing_bind_address(const struct sockaddr *addr, socklen_t addrlen);
int evdns_resolve_ipv4(const char *name, int flags, evdns_callback_type callback, void *ptr);
int evdns_resolve_ipv6(const char *name, int flags, evdns_callback_type callback, void *ptr);
struct in_addr;
struct in6_addr;
int evdns_resolve_reverse(const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr);
int evdns_resolve_reverse_ipv6(const struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr);
int evdns_set_option(const char *option, const char *val, int flags);
int evdns_resolv_conf_parse(int flags, const char *);
#ifdef _WIN32
int evdns_config_windows_nameservers(void);
#endif
void evdns_search_clear(void);
void evdns_search_add(const char *domain);
void evdns_search_ndots_set(const int ndots);
typedef void (*evdns_debug_log_fn_type)(int is_warning, const char *msg);
void evdns_set_log_fn(evdns_debug_log_fn_type fn);
void evdns_set_transaction_id_fn(uint16_t (*fn)(void));
void evdns_set_random_bytes_fn(void (*fn)(char *, size_t));
#define DNS_NO_SEARCH 1
/* Structures and functions used to implement a DNS server. */
struct evdns_server_request {
int flags;
int nquestions;
struct evdns_server_question **questions;
};
struct evdns_server_question {
int type;
int dns_question_class;
char name[1];
};
typedef void (*evdns_request_callback_fn_type)(struct evdns_server_request *, void *);
#define EVDNS_ANSWER_SECTION 0
#define EVDNS_AUTHORITY_SECTION 1
#define EVDNS_ADDITIONAL_SECTION 2
#define EVDNS_TYPE_A 1
#define EVDNS_TYPE_NS 2
#define EVDNS_TYPE_CNAME 5
#define EVDNS_TYPE_SOA 6
#define EVDNS_TYPE_PTR 12
#define EVDNS_TYPE_MX 15
#define EVDNS_TYPE_TXT 16
#define EVDNS_TYPE_AAAA 28
#define EVDNS_QTYPE_AXFR 252
#define EVDNS_QTYPE_ALL 255
#define EVDNS_CLASS_INET 1
struct evdns_server_port *evdns_add_server_port(tor_socket_t socket, int is_tcp, evdns_request_callback_fn_type callback, void *user_data);
void evdns_close_server_port(struct evdns_server_port *port);
int evdns_server_request_add_reply(struct evdns_server_request *req, int section, const char *name, int type, int class, int ttl, int datalen, int is_name, const char *data);
int evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, const void *addrs, int ttl);
int evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, const void *addrs, int ttl);
int evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char *inaddr_name, const char *hostname, int ttl);
int evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl);
struct sockaddr;
int evdns_server_request_get_requesting_addr(struct evdns_server_request *req, struct sockaddr *sa, int addr_len);
int evdns_server_request_respond(struct evdns_server_request *req, int err);
int evdns_server_request_drop(struct evdns_server_request *req);
#endif // !EVENTDNS_H

1
src/ext/include.am
View File

@ -5,7 +5,6 @@ EXTRA_DIST += src/ext/README
EXTHEADERS = \ EXTHEADERS = \
src/ext/ht.h \ src/ext/ht.h \
src/ext/eventdns.h \
src/ext/tinytest.h \ src/ext/tinytest.h \
src/ext/tor_readpassphrase.h \ src/ext/tor_readpassphrase.h \
src/ext/strlcat.c \ src/ext/strlcat.c \

2
src/or/config.c
View File

@ -7202,8 +7202,6 @@ init_libevent(const or_options_t *options)
*/ */
suppress_libevent_log_msg("Function not implemented"); suppress_libevent_log_msg("Function not implemented");
tor_check_libevent_header_compatibility();
memset(&cfg, 0, sizeof(cfg)); memset(&cfg, 0, sizeof(cfg));
cfg.disable_iocp = options->DisableIOCP; cfg.disable_iocp = options->DisableIOCP;
cfg.num_cpus = get_num_cpus(options); cfg.num_cpus = get_num_cpus(options);

4
src/or/control.c
View File

@ -51,11 +51,7 @@
#include <sys/resource.h> #include <sys/resource.h>
#endif #endif
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#include "crypto_s2k.h" #include "crypto_s2k.h"
#include "procmon.h" #include "procmon.h"

4
src/or/cpuworker.c
View File

@ -23,11 +23,7 @@
#include "router.h" #include "router.h"
#include "workqueue.h" #include "workqueue.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
static void queue_pending_tasks(void); static void queue_pending_tasks(void);

72
src/or/dns.c
View File

@ -27,61 +27,8 @@
#include "router.h" #include "router.h"
#include "ht.h" #include "ht.h"
#include "sandbox.h" #include "sandbox.h"
#ifdef HAVE_EVENT2_DNS_H
#include <event2/event.h> #include <event2/event.h>
#include <event2/dns.h> #include <event2/dns.h>
#else
#include <event.h>
#include "eventdns.h"
#ifndef HAVE_EVDNS_SET_DEFAULT_OUTGOING_BIND_ADDRESS
#define HAVE_EVDNS_SET_DEFAULT_OUTGOING_BIND_ADDRESS
#endif
#endif
#ifndef HAVE_EVENT2_DNS_H
struct evdns_base;
struct evdns_request;
#define evdns_base_new(x,y) tor_malloc(1)
#define evdns_base_clear_nameservers_and_suspend(base) \
evdns_clear_nameservers_and_suspend()
#define evdns_base_search_clear(base) evdns_search_clear()
#define evdns_base_set_default_outgoing_bind_address(base, a, len) \
evdns_set_default_outgoing_bind_address((a),(len))
#define evdns_base_resolv_conf_parse(base, options, fname) \
evdns_resolv_conf_parse((options), (fname))
#define evdns_base_count_nameservers(base) \
evdns_count_nameservers()
#define evdns_base_resume(base) \
evdns_resume()
#define evdns_base_config_windows_nameservers(base) \
evdns_config_windows_nameservers()
#define evdns_base_set_option_(base, opt, val) \
evdns_set_option((opt),(val),DNS_OPTIONS_ALL)
/* Note: our internal eventdns.c, plus Libevent 1.4, used a 1 return to
* signify failure to launch a resolve. Libevent 2.0 uses a -1 return to
* signify a failure on a resolve, though if we're on Libevent 2.0, we should
* have event2/dns.h and never hit these macros. Regardless, 0 is success. */
#define evdns_base_resolve_ipv4(base, addr, options, cb, ptr) \
((evdns_resolve_ipv4((addr), (options), (cb), (ptr))!=0) \
? NULL : ((void*)1))
#define evdns_base_resolve_ipv6(base, addr, options, cb, ptr) \
((evdns_resolve_ipv6((addr), (options), (cb), (ptr))!=0) \
? NULL : ((void*)1))
#define evdns_base_resolve_reverse(base, addr, options, cb, ptr) \
((evdns_resolve_reverse((addr), (options), (cb), (ptr))!=0) \
? NULL : ((void*)1))
#define evdns_base_resolve_reverse_ipv6(base, addr, options, cb, ptr) \
((evdns_resolve_reverse_ipv6((addr), (options), (cb), (ptr))!=0) \
? NULL : ((void*)1))
#elif defined(LIBEVENT_VERSION_NUMBER) && LIBEVENT_VERSION_NUMBER < 0x02000303
#define evdns_base_set_option_(base, opt, val) \
evdns_base_set_option((base), (opt),(val),DNS_OPTIONS_ALL)
#else
#define evdns_base_set_option_ evdns_base_set_option
#endif
/** How long will we wait for an answer from the resolver before we decide /** How long will we wait for an answer from the resolver before we decide
* that the resolver is wedged? */ * that the resolver is wedged? */
@ -1373,23 +1320,6 @@ configure_nameservers(int force)
} }
} }
#ifdef HAVE_EVDNS_SET_DEFAULT_OUTGOING_BIND_ADDRESS
if (! tor_addr_is_null(&options->OutboundBindAddressIPv4_)) {
int socklen;
struct sockaddr_storage ss;
socklen = tor_addr_to_sockaddr(&options->OutboundBindAddressIPv4_, 0,
(struct sockaddr *)&ss, sizeof(ss));
if (socklen <= 0) {
log_warn(LD_BUG, "Couldn't convert outbound bind address to sockaddr."
" Ignoring.");
} else {
evdns_base_set_default_outgoing_bind_address(the_evdns_base,
(struct sockaddr *)&ss,
socklen);
}
}
#endif
evdns_set_log_fn(evdns_log_cb); evdns_set_log_fn(evdns_log_cb);
if (conf_fname) { if (conf_fname) {
log_debug(LD_FS, "stat()ing %s", conf_fname); log_debug(LD_FS, "stat()ing %s", conf_fname);
@ -1454,7 +1384,7 @@ configure_nameservers(int force)
} }
#endif #endif
#define SET(k,v) evdns_base_set_option_(the_evdns_base, (k), (v)) #define SET(k,v) evdns_base_set_option(the_evdns_base, (k), (v))
if (evdns_base_count_nameservers(the_evdns_base) == 1) { if (evdns_base_count_nameservers(the_evdns_base) == 1) {
SET("max-timeouts:", "16"); SET("max-timeouts:", "16");

4
src/or/dnsserv.c
View File

@ -17,14 +17,10 @@
#include "control.h" #include "control.h"
#include "main.h" #include "main.h"
#include "policies.h" #include "policies.h"
#ifdef HAVE_EVENT2_DNS_H
#include <event2/dns.h> #include <event2/dns.h>
#include <event2/dns_compat.h> #include <event2/dns_compat.h>
/* XXXX this implies we want an improved evdns */ /* XXXX this implies we want an improved evdns */
#include <event2/dns_struct.h> #include <event2/dns_struct.h>
#else
#include "eventdns.h"
#endif
/** Helper function: called by evdns whenever the client sends a request to our /** Helper function: called by evdns whenever the client sends a request to our
* DNSPort. We need to eventually answer the request <b>req</b>. * DNSPort. We need to eventually answer the request <b>req</b>.

22
src/or/eventdns_tor.h
View File

@ -1,22 +0,0 @@
/* Copyright (c) 2007-2016, The Tor Project, Inc. */
/* See LICENSE for licensing information */
#ifndef TOR_EVENTDNS_TOR_H
#define TOR_EVENTDNS_TOR_H
#include "orconfig.h"
#define DNS_USE_OPENSSL_FOR_ID
#ifndef HAVE_UINT
typedef unsigned int uint;
#endif
#ifndef HAVE_U_CHAR
typedef unsigned char u_char;
#endif
#include "torint.h"
/* These are for debugging possible memory leaks. */
#include "util.h"
#include "compat.h"
#endif

8
src/or/include.am
View File

@ -17,12 +17,6 @@ endif
EXTRA_DIST+= src/or/ntmain.c src/or/Makefile.nmake EXTRA_DIST+= src/or/ntmain.c src/or/Makefile.nmake
if USE_EXTERNAL_EVDNS
evdns_source=
else
evdns_source=src/ext/eventdns.c
endif
LIBTOR_A_SOURCES = \ LIBTOR_A_SOURCES = \
src/or/addressmap.c \ src/or/addressmap.c \
src/or/buffers.c \ src/or/buffers.c \
@ -86,7 +80,6 @@ LIBTOR_A_SOURCES = \
src/or/status.c \ src/or/status.c \
src/or/torcert.c \ src/or/torcert.c \
src/or/onion_ntor.c \ src/or/onion_ntor.c \
$(evdns_source) \
$(tor_platform_source) $(tor_platform_source)
src_or_libtor_a_SOURCES = $(LIBTOR_A_SOURCES) src_or_libtor_a_SOURCES = $(LIBTOR_A_SOURCES)
@ -157,7 +150,6 @@ ORHEADERS = \
src/or/dns.h \ src/or/dns.h \
src/or/dns_structs.h \ src/or/dns_structs.h \
src/or/dnsserv.h \ src/or/dnsserv.h \
src/or/eventdns_tor.h \
src/or/ext_orport.h \ src/or/ext_orport.h \
src/or/fallback_dirs.inc \ src/or/fallback_dirs.inc \
src/or/fp_pair.h \ src/or/fp_pair.h \

4
src/or/main.c
View File

@ -69,11 +69,7 @@
#include "memarea.h" #include "memarea.h"
#include "sandbox.h" #include "sandbox.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#ifdef USE_BUFFEREVENTS #ifdef USE_BUFFEREVENTS
#include <event2/bufferevent.h> #include <event2/bufferevent.h>

4
src/or/ntmain.c
View File

@ -16,11 +16,7 @@
#include "main.h" #include "main.h"
#include "ntmain.h" #include "ntmain.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#include <windows.h> #include <windows.h>
#define GENSRV_SERVICENAME "tor" #define GENSRV_SERVICENAME "tor"

4
src/or/periodic.c
View File

@ -12,11 +12,7 @@
#include "config.h" #include "config.h"
#include "periodic.h" #include "periodic.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
/** We disable any interval greater than this number of seconds, on the /** We disable any interval greater than this number of seconds, on the
* grounds that it is probably an absolute time mistakenly passed in as a * grounds that it is probably an absolute time mistakenly passed in as a

4
src/or/scheduler.c
View File

@ -15,11 +15,7 @@
#define SCHEDULER_PRIVATE_ #define SCHEDULER_PRIVATE_
#include "scheduler.h" #include "scheduler.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
/* /*
* Scheduler high/low watermarks * Scheduler high/low watermarks

4
src/test/test-timers.c
View File

@ -7,11 +7,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#include "compat.h" #include "compat.h"
#include "compat_libevent.h" #include "compat_libevent.h"

102
src/test/test_compat_libevent.c
View File

@ -9,15 +9,11 @@
#include "compat_libevent.h" #include "compat_libevent.h"
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#include <event2/thread.h> #include <event2/thread.h>
#ifdef USE_BUFFEREVENTS #ifdef USE_BUFFEREVENTS
#include <event2/bufferevent.h> #include <event2/bufferevent.h>
#endif #endif
#else
#include <event.h>
#endif
#include "log_test_helpers.h" #include "log_test_helpers.h"
@ -106,98 +102,6 @@ test_compat_libevent_logging_callback(void *ignored)
teardown_capture_of_logs(previous_log); teardown_capture_of_logs(previous_log);
} }
static void
test_compat_libevent_le_versions_compatibility(void *ignored)
{
(void)ignored;
int res;
res = le_versions_compatibility(LE_OTHER);
tt_int_op(res, OP_EQ, 0);
res = le_versions_compatibility(V_OLD(0,9,'c'));
tt_int_op(res, OP_EQ, 1);
res = le_versions_compatibility(V(1,3,98));
tt_int_op(res, OP_EQ, 2);
res = le_versions_compatibility(V(1,4,98));
tt_int_op(res, OP_EQ, 3);
res = le_versions_compatibility(V(1,5,0));
tt_int_op(res, OP_EQ, 4);
res = le_versions_compatibility(V(2,0,0));
tt_int_op(res, OP_EQ, 4);
res = le_versions_compatibility(V(2,0,2));
tt_int_op(res, OP_EQ, 5);
done:
(void)0;
}
static void
test_compat_libevent_tor_decode_libevent_version(void *ignored)
{
(void)ignored;
le_version_t res;
res = tor_decode_libevent_version("SOMETHING WRONG");
tt_int_op(res, OP_EQ, LE_OTHER);
res = tor_decode_libevent_version("1.4.11");
tt_int_op(res, OP_EQ, V(1,4,11));
res = tor_decode_libevent_version("1.4.12b-stable");
tt_int_op(res, OP_EQ, V(1,4,12));
res = tor_decode_libevent_version("1.4.17b_stable");
tt_int_op(res, OP_EQ, V(1,4,17));
res = tor_decode_libevent_version("1.4.12!stable");
tt_int_op(res, OP_EQ, LE_OTHER);
res = tor_decode_libevent_version("1.4.12b!stable");
tt_int_op(res, OP_EQ, LE_OTHER);
res = tor_decode_libevent_version("1.4.13-");
tt_int_op(res, OP_EQ, V(1,4,13));
res = tor_decode_libevent_version("1.4.14_");
tt_int_op(res, OP_EQ, V(1,4,14));
res = tor_decode_libevent_version("1.4.15c-");
tt_int_op(res, OP_EQ, V(1,4,15));
res = tor_decode_libevent_version("1.4.16c_");
tt_int_op(res, OP_EQ, V(1,4,16));
res = tor_decode_libevent_version("1.4.17-s");
tt_int_op(res, OP_EQ, V(1,4,17));
res = tor_decode_libevent_version("1.5");
tt_int_op(res, OP_EQ, V(1,5,0));
res = tor_decode_libevent_version("1.2");
tt_int_op(res, OP_EQ, V(1,2,0));
res = tor_decode_libevent_version("1.2-");
tt_int_op(res, OP_EQ, LE_OTHER);
res = tor_decode_libevent_version("1.6e");
tt_int_op(res, OP_EQ, V_OLD(1,6,'e'));
done:
(void)0;
}
#if defined(LIBEVENT_VERSION)
#define HEADER_VERSION LIBEVENT_VERSION
#elif defined(_EVENT_VERSION)
#define HEADER_VERSION _EVENT_VERSION
#endif
static void static void
test_compat_libevent_header_version(void *ignored) test_compat_libevent_header_version(void *ignored)
{ {
@ -205,7 +109,7 @@ test_compat_libevent_header_version(void *ignored)
const char *res; const char *res;
res = tor_libevent_get_header_version_str(); res = tor_libevent_get_header_version_str();
tt_str_op(res, OP_EQ, HEADER_VERSION); tt_str_op(res, OP_EQ, LIBEVENT_VERSION);
done: done:
(void)0; (void)0;
@ -214,10 +118,6 @@ test_compat_libevent_header_version(void *ignored)
struct testcase_t compat_libevent_tests[] = { struct testcase_t compat_libevent_tests[] = {
{ "logging_callback", test_compat_libevent_logging_callback, { "logging_callback", test_compat_libevent_logging_callback,
TT_FORK, NULL, NULL }, TT_FORK, NULL, NULL },
{ "le_versions_compatibility",
test_compat_libevent_le_versions_compatibility, 0, NULL, NULL },
{ "tor_decode_libevent_version",
test_compat_libevent_tor_decode_libevent_version, 0, NULL, NULL },
{ "header_version", test_compat_libevent_header_version, 0, NULL, NULL }, { "header_version", test_compat_libevent_header_version, 0, NULL, NULL },
END_OF_TESTCASES END_OF_TESTCASES
}; };

11
src/test/test_scheduler.c
View File

@ -5,12 +5,7 @@
#include "orconfig.h" #include "orconfig.h"
/* Libevent stuff */
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#define TOR_CHANNEL_INTERNAL_ #define TOR_CHANNEL_INTERNAL_
#define CHANNEL_PRIVATE_ #define CHANNEL_PRIVATE_
@ -90,9 +85,7 @@ mock_event_free_all(void)
static void static void
mock_event_init(void) mock_event_init(void)
{ {
#ifdef HAVE_EVENT2_EVENT_H
struct event_config *cfg = NULL; struct event_config *cfg = NULL;
#endif
tt_ptr_op(mock_event_base, ==, NULL); tt_ptr_op(mock_event_base, ==, NULL);
@ -102,7 +95,6 @@ mock_event_init(void)
*/ */
if (!mock_event_base) { if (!mock_event_base) {
#ifdef HAVE_EVENT2_EVENT_H
cfg = event_config_new(); cfg = event_config_new();
#if LIBEVENT_VERSION_NUMBER >= V(2,0,9) #if LIBEVENT_VERSION_NUMBER >= V(2,0,9)
/* We can enable changelist support with epoll, since we don't give /* We can enable changelist support with epoll, since we don't give
@ -111,9 +103,6 @@ mock_event_init(void)
#endif #endif
mock_event_base = event_base_new_with_config(cfg); mock_event_base = event_base_new_with_config(cfg);
event_config_free(cfg); event_config_free(cfg);
#else
mock_event_base = event_init();
#endif
} }
tt_assert(mock_event_base != NULL); tt_assert(mock_event_base != NULL);

4
src/test/test_workqueue.c
View File

@ -12,11 +12,7 @@
#include "compat_libevent.h" #include "compat_libevent.h"
#include <stdio.h> #include <stdio.h>
#ifdef HAVE_EVENT2_EVENT_H
#include <event2/event.h> #include <event2/event.h>
#else
#include <event.h>
#endif
#define MAX_INFLIGHT (1<<16) #define MAX_INFLIGHT (1<<16)

14
src/win32/orconfig.h
View File

@ -17,15 +17,6 @@
/* Define to 1 if you have the <errno.h> header file. */ /* Define to 1 if you have the <errno.h> header file. */
#define HAVE_ERRNO_H #define HAVE_ERRNO_H
/* Define to 1 if you have the `event_get_method' function. */
#define HAVE_EVENT_GET_METHOD 1
/* Define to 1 if you have the `event_get_version' function. */
#define HAVE_EVENT_GET_VERSION 1
/* Define to 1 if you have the `event_set_log_callback' function. */
#define HAVE_EVENT_SET_LOG_CALLBACK 1
/* Define to 1 if you have the <fcntl.h> header file. */ /* Define to 1 if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H #define HAVE_FCNTL_H
@ -223,8 +214,6 @@
/* Define to 1 iff unaligned int access is allowed */ /* Define to 1 iff unaligned int access is allowed */
#define UNALIGNED_INT_ACCESS_OK #define UNALIGNED_INT_ACCESS_OK
#define HAVE_EVENT_H
/* Define to 1 iff we represent negative integers with two's complement */ /* Define to 1 iff we represent negative integers with two's complement */
#define USING_TWOS_COMPLEMENT #define USING_TWOS_COMPLEMENT
@ -237,10 +226,7 @@
#define HAVE_STRUCT_IN6_ADDR #define HAVE_STRUCT_IN6_ADDR
#define RSHIFT_DOES_SIGN_EXTEND #define RSHIFT_DOES_SIGN_EXTEND
#define FLEXIBLE_ARRAY_MEMBER 0 #define FLEXIBLE_ARRAY_MEMBER 0
#define HAVE_EVENT2_EVENT_H
#define SHARE_DATADIR "" #define SHARE_DATADIR ""
#define HAVE_EVENT2_DNS_H
#define HAVE_EVENT_BASE_LOOPEXIT
#define USE_CURVE25519_DONNA #define USE_CURVE25519_DONNA
#define ENUM_VALS_ARE_SIGNED 1 #define ENUM_VALS_ARE_SIGNED 1