20 files changed, 602 insertions, 97 deletions

diff --git a/sntp/libevent/test/include.am b/sntp/libevent/test/include.am
index ca36da4..4cd49ef 100644
--- a/sntp/libevent/test/include.am
+++ b/sntp/libevent/test/include.am
@@ -49,7 +49,8 @@ TESTS = test/test-script.sh
 test/test-script.sh: test/test.sh
 	cp $(top_srcdir)/test/test.sh $@
 
-DISTCLEANFILES += test/test-script.sh test/regress.gen.c test/regress.gen.h
+DISTCLEANFILES += test/test-script.sh
+DISTCLEANFILES += test/regress.gen.c test/regress.gen.h
 
 if BUILD_REGRESS
 BUILT_SOURCES += test/regress.gen.c test/regress.gen.h
diff --git a/sntp/libevent/test/regress.c b/sntp/libevent/test/regress.c
index 4d17b67..399ba2f 100644
--- a/sntp/libevent/test/regress.c
+++ b/sntp/libevent/test/regress.c
@@ -944,17 +944,18 @@ signal_cb(evutil_socket_t fd, short event, void *arg)
 }
 
 static void
-test_simplesignal(void)
+test_simplesignal_impl(int find_reorder)
 {
 	struct event ev;
 	struct itimerval itv;
 
-	setup_test("Simple signal: ");
 	evsignal_set(&ev, SIGALRM, signal_cb, &ev);
 	evsignal_add(&ev, NULL);
 	/* find bugs in which operations are re-ordered */
-	evsignal_del(&ev);
-	evsignal_add(&ev, NULL);
+	if (find_reorder) {
+		evsignal_del(&ev);
+		evsignal_add(&ev, NULL);
+	}
 
 	memset(&itv, 0, sizeof(itv));
 	itv.it_value.tv_sec = 0;
@@ -971,6 +972,20 @@ test_simplesignal(void)
 }
 
 static void
+test_simplestsignal(void)
+{
+	setup_test("Simplest one signal: ");
+	test_simplesignal_impl(0);
+}
+
+static void
+test_simplesignal(void)
+{
+	setup_test("Simple signal: ");
+	test_simplesignal_impl(1);
+}
+
+static void
 test_multiplesignal(void)
 {
 	struct event ev_one, ev_two;
@@ -1658,7 +1673,7 @@ static void
 test_active_later(void *ptr)
 {
 	struct basic_test_data *data = ptr;
-	struct event *ev1, *ev2;
+	struct event *ev1 = NULL, *ev2 = NULL;
 	struct event ev3, ev4;
 	struct timeval qsec = {0, 100000};
 	ev1 = event_new(data->base, data->pair[0], EV_READ|EV_PERSIST, read_and_drain_cb, NULL);
@@ -1693,10 +1708,15 @@ test_active_later(void *ptr)
 	 * it. */
 	event_active_later_(&ev3, EV_READ);
 	event_base_assert_ok_(data->base);
+
+end:
+	if (ev1)
+		event_free(ev1);
+	if (ev2)
+		event_free(ev2);
+
 	event_base_free(data->base);
 	data->base = NULL;
-end:
-	;
 }
 
 
@@ -2281,7 +2301,7 @@ evtag_fuzz(void *ptr)
 
 	for (j = 0; j < 100; j++) {
 		for (i = 0; i < (int)sizeof(buffer); i++)
-			buffer[i] = rand();
+			buffer[i] = test_weakrand();
 		evbuffer_drain(tmp, -1);
 		evbuffer_add(tmp, buffer, sizeof(buffer));
 
@@ -3294,6 +3314,7 @@ struct testcase_t evtag_testcases[] = {
 
 struct testcase_t signal_testcases[] = {
 #ifndef _WIN32
+	LEGACY(simplestsignal, TT_ISOLATED),
 	LEGACY(simplesignal, TT_ISOLATED),
 	LEGACY(multiplesignal, TT_ISOLATED),
 	LEGACY(immediatesignal, TT_ISOLATED),
diff --git a/sntp/libevent/test/regress.h b/sntp/libevent/test/regress.h
index a9892b0..bbfefe6 100644
--- a/sntp/libevent/test/regress.h
+++ b/sntp/libevent/test/regress.h
@@ -53,6 +53,10 @@ extern struct testcase_t listener_testcases[];
 extern struct testcase_t listener_iocp_testcases[];
 extern struct testcase_t thread_testcases[];
 
+extern struct evutil_weakrand_state test_weakrand_state;
+
+#define test_weakrand() (evutil_weakrand_(&test_weakrand_state))
+
 void regress_threads(void *);
 void test_bufferevent_zlib(void *);
 
@@ -114,7 +118,7 @@ int test_ai_eq_(const struct evutil_addrinfo *ai, const char *sockaddr_port,
 	} while (0)
 
 #define test_timeval_diff_leq(tv1, tv2, diff, tolerance)		\
-	tt_int_op(abs(timeval_msec_diff((tv1), (tv2)) - diff), <=, tolerance)
+	tt_int_op(labs(timeval_msec_diff((tv1), (tv2)) - diff), <=, tolerance)
 
 #define test_timeval_diff_eq(tv1, tv2, diff)				\
 	test_timeval_diff_leq((tv1), (tv2), (diff), 50)
diff --git a/sntp/libevent/test/regress_buffer.c b/sntp/libevent/test/regress_buffer.c
index ccb1487..4d6a5de 100644
--- a/sntp/libevent/test/regress_buffer.c
+++ b/sntp/libevent/test/regress_buffer.c
@@ -246,7 +246,7 @@ test_evbuffer(void *ptr)
 	if (memcmp(evbuffer_pullup(
 			   evb, -1), buffer, sizeof(buffer) / 2) != 0 ||
 	    memcmp(evbuffer_pullup(
-			   evb_two, -1), buffer, sizeof(buffer) != 0))
+			   evb_two, -1), buffer, sizeof(buffer)) != 0)
 		tt_abort_msg("Pullup did not preserve content");
 
 	evbuffer_validate(evb);
@@ -863,6 +863,10 @@ test_evbuffer_add_file(void *ptr)
 		evutil_closesocket(pair[0]);
 	if (pair[1] >= 0)
 		evutil_closesocket(pair[1]);
+	if (wev)
+		event_free(wev);
+	if (rev)
+		event_free(rev);
 	if (tmpfilename) {
 		unlink(tmpfilename);
 		free(tmpfilename);
@@ -1534,9 +1538,9 @@ test_evbuffer_callbacks(void *ptr)
 	tt_assert(!evbuffer_remove_cb(buf, log_change_callback, buf_out2));
 	evbuffer_validate(buf);
 
-	tt_str_op(evbuffer_pullup(buf_out1, -1), ==,
+	tt_str_op((const char *) evbuffer_pullup(buf_out1, -1), ==,
 		  "0->36; 36->26; 26->31; 31->38; ");
-	tt_str_op(evbuffer_pullup(buf_out2, -1), ==,
+	tt_str_op((const char *) evbuffer_pullup(buf_out2, -1), ==,
 		  "0->36; 31->38; 38->0; 0->1; ");
 	evbuffer_drain(buf_out1, evbuffer_get_length(buf_out1));
 	evbuffer_drain(buf_out2, evbuffer_get_length(buf_out2));
@@ -1552,7 +1556,7 @@ test_evbuffer_callbacks(void *ptr)
 	tt_uint_op(evbuffer_get_length(buf_out2), ==, 0);
 	evbuffer_setcb(buf, NULL, NULL);
 	evbuffer_add_printf(buf, "This will not.");
-	tt_str_op(evbuffer_pullup(buf, -1), ==, "This will not.");
+	tt_str_op((const char *) evbuffer_pullup(buf, -1), ==, "This will not.");
 	evbuffer_validate(buf);
 	evbuffer_drain(buf, evbuffer_get_length(buf));
 	evbuffer_validate(buf);
@@ -1660,7 +1664,7 @@ test_evbuffer_add_reference(void *ptr)
 	evbuffer_add(buf1, "You shake and shake the ", 24);
 	evbuffer_add_reference(buf1, "ketchup bottle", 14, ref_done_cb,
 	    (void*)3333);
-	evbuffer_add(buf1, ". Nothing comes and then a lot'll.", 42);
+	evbuffer_add(buf1, ". Nothing comes and then a lot'll.", 35);
 	evbuffer_free(buf1);
 	buf1 = NULL;
 	tt_int_op(ref_done_cb_called_count, ==, 3);
@@ -1840,6 +1844,42 @@ end:
 }
 
 static void
+test_evbuffer_peek_first_gt(void *info)
+{
+	struct evbuffer *buf = NULL, *tmp_buf = NULL;
+	struct evbuffer_ptr ptr;
+	struct evbuffer_iovec v[2];
+
+	buf = evbuffer_new();
+	tmp_buf = evbuffer_new();
+	evbuffer_add_printf(tmp_buf, "Contents of chunk 100\n");
+	evbuffer_add_buffer(buf, tmp_buf);
+	evbuffer_add_printf(tmp_buf, "Contents of chunk 1\n");
+	evbuffer_add_buffer(buf, tmp_buf);
+
+	evbuffer_ptr_set(buf, &ptr, 0, EVBUFFER_PTR_SET);
+
+	/** The only case that matters*/
+	tt_int_op(evbuffer_peek(buf, -1, &ptr, NULL, 0), ==, 2);
+	/** Just in case */
+	tt_int_op(evbuffer_peek(buf, -1, &ptr, v, 2), ==, 2);
+
+	evbuffer_ptr_set(buf, &ptr, 20, EVBUFFER_PTR_ADD);
+	tt_int_op(evbuffer_peek(buf, -1, &ptr, NULL, 0), ==, 2);
+	tt_int_op(evbuffer_peek(buf, -1, &ptr, v, 2), ==, 2);
+	tt_int_op(evbuffer_peek(buf, 2, &ptr, NULL, 0), ==, 1);
+	tt_int_op(evbuffer_peek(buf, 2, &ptr, v, 2), ==, 1);
+	tt_int_op(evbuffer_peek(buf, 3, &ptr, NULL, 0), ==, 2);
+	tt_int_op(evbuffer_peek(buf, 3, &ptr, v, 2), ==, 2);
+
+end:
+	if (buf)
+		evbuffer_free(buf);
+	if (tmp_buf)
+		evbuffer_free(tmp_buf);
+}
+
+static void
 test_evbuffer_peek(void *info)
 {
 	struct evbuffer *buf = NULL, *tmp_buf = NULL;
@@ -2096,7 +2136,7 @@ test_evbuffer_copyout(void *dummy)
 	    "When the rich Allobrogenses never kept amanuenses, "
 	    "And our only plots were piled in lakes at Berne.";
 	/* -- Kipling, "In The Neolithic Age" */
-	char tmp[256];
+	char tmp[1024];
 	struct evbuffer_ptr ptr;
 	struct evbuffer *buf;
 
@@ -2206,6 +2246,7 @@ struct testcase_t evbuffer_testcases[] = {
 	{ "multicast_drain", test_evbuffer_multicast_drain, 0, NULL, NULL },
 	{ "prepend", test_evbuffer_prepend, TT_FORK, NULL, NULL },
 	{ "peek", test_evbuffer_peek, 0, NULL, NULL },
+	{ "peek_first_gt", test_evbuffer_peek_first_gt, 0, NULL, NULL },
 	{ "freeze_start", test_evbuffer_freeze, 0, &nil_setup, (void*)"start" },
 	{ "freeze_end", test_evbuffer_freeze, 0, &nil_setup, (void*)"end" },
 	{ "add_iovec", test_evbuffer_add_iovec, 0, NULL, NULL},
diff --git a/sntp/libevent/test/regress_bufferevent.c b/sntp/libevent/test/regress_bufferevent.c
index 4ec2dcc..a1998ba 100644
--- a/sntp/libevent/test/regress_bufferevent.c
+++ b/sntp/libevent/test/regress_bufferevent.c
@@ -75,6 +75,7 @@
 #include "event2/util.h"
 
 #include "bufferevent-internal.h"
+#include "evthread-internal.h"
 #include "util-internal.h"
 #ifdef _WIN32
 #include "iocp-internal.h"
@@ -173,9 +174,9 @@ test_bufferevent_impl(int use_pair)
 
 	event_dispatch();
 
-	bufferevent_free(bev1);
-	tt_ptr_op(bufferevent_pair_get_partner(bev2), ==, NULL);
 	bufferevent_free(bev2);
+	tt_ptr_op(bufferevent_pair_get_partner(bev1), ==, NULL);
+	bufferevent_free(bev1);
 
 	if (test_ok != 2)
 		test_ok = 0;
@@ -195,6 +196,143 @@ test_bufferevent_pair(void)
 	test_bufferevent_impl(1);
 }
 
+#if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
+/**
+ * Trace lock/unlock/alloc/free for locks.
+ * (More heavier then evthread_debug*)
+ */
+typedef struct
+{
+	void *lock;
+	enum {
+		ALLOC, FREE,
+	} status;
+	size_t locked /** allow recursive locking */;
+} lock_wrapper;
+struct lock_unlock_base
+{
+	/* Original callbacks */
+	struct evthread_lock_callbacks cbs;
+	/* Map of locks */
+	lock_wrapper *locks;
+	size_t nr_locks;
+} lu_base = {
+	.locks = NULL,
+};
+
+static lock_wrapper *lu_find(void *lock_)
+{
+	size_t i;
+	for (i = 0; i < lu_base.nr_locks; ++i) {
+		lock_wrapper *lock = &lu_base.locks[i];
+		if (lock->lock == lock_)
+			return lock;
+	}
+	return NULL;
+}
+
+static void *trace_lock_alloc(unsigned locktype)
+{
+	++lu_base.nr_locks;
+	lu_base.locks = realloc(lu_base.locks,
+		sizeof(lock_wrapper) * lu_base.nr_locks);
+	void *lock = lu_base.cbs.alloc(locktype);
+	lu_base.locks[lu_base.nr_locks - 1] = (lock_wrapper){ lock, ALLOC, 0 };
+	return lock;
+}
+static void trace_lock_free(void *lock_, unsigned locktype)
+{
+	lock_wrapper *lock = lu_find(lock_);
+	if (!lock || lock->status == FREE || lock->locked) {
+		__asm__("int3");
+		TT_FAIL(("lock: free error"));
+	} else {
+		lock->status = FREE;
+		lu_base.cbs.free(lock_, locktype);
+	}
+}
+static int trace_lock_lock(unsigned mode, void *lock_)
+{
+	lock_wrapper *lock = lu_find(lock_);
+	if (!lock || lock->status == FREE) {
+		TT_FAIL(("lock: lock error"));
+		return -1;
+	} else {
+		++lock->locked;
+		return lu_base.cbs.lock(mode, lock_);
+	}
+}
+static int trace_lock_unlock(unsigned mode, void *lock_)
+{
+	lock_wrapper *lock = lu_find(lock_);
+	if (!lock || lock->status == FREE || !lock->locked) {
+		TT_FAIL(("lock: unlock error"));
+		return -1;
+	} else {
+		--lock->locked;
+		return lu_base.cbs.unlock(mode, lock_);
+	}
+}
+static void lock_unlock_free_thread_cbs()
+{
+	event_base_free(NULL);
+
+	/** drop immutable flag */
+	evthread_set_lock_callbacks(NULL);
+	/** avoid calling of event_global_setup_locks_() for new cbs */
+	libevent_global_shutdown();
+	/** drop immutable flag for non-debug ops (since called after shutdown) */
+	evthread_set_lock_callbacks(NULL);
+}
+
+static int use_lock_unlock_profiler(void)
+{
+	struct evthread_lock_callbacks cbs = {
+		EVTHREAD_LOCK_API_VERSION,
+		EVTHREAD_LOCKTYPE_RECURSIVE,
+		trace_lock_alloc,
+		trace_lock_free,
+		trace_lock_lock,
+		trace_lock_unlock,
+	};
+	memcpy(&lu_base.cbs, evthread_get_lock_callbacks(),
+		sizeof(lu_base.cbs));
+	{
+		lock_unlock_free_thread_cbs();
+
+		evthread_set_lock_callbacks(&cbs);
+		/** re-create debug locks correctly */
+		evthread_enable_lock_debugging();
+
+		event_init();
+	}
+	return 0;
+}
+static void free_lock_unlock_profiler(struct basic_test_data *data)
+{
+	lock_unlock_free_thread_cbs();
+	free(lu_base.locks);
+	data->base = NULL;
+}
+
+static void test_bufferevent_pair_release_lock(void *arg)
+{
+	struct basic_test_data *data = arg;
+	use_lock_unlock_profiler();
+	{
+		struct bufferevent *pair[2];
+		if (!bufferevent_pair_new(NULL, BEV_OPT_THREADSAFE, pair)) {
+			bufferevent_free(pair[0]);
+			bufferevent_free(pair[1]);
+		} else
+			tt_abort_perror("bufferevent_pair_new");
+	}
+	free_lock_unlock_profiler(data);
+end:
+	;
+}
+#endif
+
 /*
  * test watermarks and bufferevent
  */
@@ -287,6 +425,11 @@ test_bufferevent_watermarks_impl(int use_pair)
 	tt_int_op(low, ==, 100);
 	tt_int_op(high, ==, 2000);
 
+	{
+	int r = bufferevent_getwatermark(bev1, EV_WRITE | EV_READ, &low, &high);
+	tt_int_op(r, !=, 0);
+	}
+
 	bufferevent_write(bev1, buffer, sizeof(buffer));
 
 	event_dispatch();
@@ -944,6 +1087,11 @@ struct testcase_t bufferevent_testcases[] = {
 
 	LEGACY(bufferevent, TT_ISOLATED),
 	LEGACY(bufferevent_pair, TT_ISOLATED),
+#if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
+	{ "bufferevent_pair_release_lock", test_bufferevent_pair_release_lock,
+	  TT_FORK|TT_ISOLATED|TT_NEED_THREADS|TT_NEED_BASE|TT_LEGACY,
+	  &basic_setup, NULL },
+#endif
 	LEGACY(bufferevent_watermarks, TT_ISOLATED),
 	LEGACY(bufferevent_pair_watermarks, TT_ISOLATED),
 	LEGACY(bufferevent_filters, TT_ISOLATED),
diff --git a/sntp/libevent/test/regress_dns.c b/sntp/libevent/test/regress_dns.c
index 338c4ee..6d6b484 100644
--- a/sntp/libevent/test/regress_dns.c
+++ b/sntp/libevent/test/regress_dns.c
@@ -406,6 +406,22 @@ dns_server(void)
 	 * the only nameserver. */
 	evdns_base_nameserver_sockaddr_add(base, (struct sockaddr*)&ss, slen, 0);
 	tt_int_op(evdns_base_count_nameservers(base), ==, 1);
+	{
+		struct sockaddr_storage ss2;
+		int slen2;
+
+		memset(&ss2, 0, sizeof(ss2));
+
+		slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, 3);
+		tt_int_op(slen2, ==, slen);
+		tt_int_op(ss2.ss_family, ==, 0);
+		slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, sizeof(ss2));
+		tt_int_op(slen2, ==, slen);
+		tt_mem_op(&ss2, ==, &ss, slen);
+
+		slen2 = evdns_base_get_nameserver_addr(base, 1, (struct sockaddr *)&ss2, sizeof(ss2));
+		tt_int_op(-1, ==, slen2);
+	}
 
 	/* Send some queries. */
 	evdns_base_resolve_ipv4(base, "zz.example.com", DNS_QUERY_NO_SEARCH,
@@ -443,6 +459,7 @@ end:
 
 static int n_replies_left;
 static struct event_base *exit_base;
+static struct evdns_server_port *exit_port;
 
 struct generic_dns_callback_result {
 	int result;
@@ -483,8 +500,14 @@ generic_dns_callback(int result, char type, int count, int ttl, void *addresses,
 		res->addrs = res->addrs_buf;
 	}
 
-	if (--n_replies_left == 0)
-		event_base_loopexit(exit_base, NULL);
+	--n_replies_left;
+	if (n_replies_left == 0) {
+		if (exit_port) {
+			evdns_close_server_port(exit_port);
+			exit_port = NULL;
+		} else
+			event_base_loopexit(exit_base, NULL);
+	}
 }
 
 static struct regress_dns_server_table search_table[] = {
@@ -664,7 +687,7 @@ end:
 }
 
 static void
-dns_retry_test(void *arg)
+dns_retry_test_impl(void *arg, int flags)
 {
 	struct basic_test_data *data = arg;
 	struct event_base *base = data->base;
@@ -681,7 +704,7 @@ dns_retry_test(void *arg)
 	tt_assert(port);
 	evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
 
-	dns = evdns_base_new(base, 0);
+	dns = evdns_base_new(base, flags);
 	tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
 	tt_assert(! evdns_base_set_option(dns, "timeout", "0.2"));
 	tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "10"));
@@ -736,6 +759,16 @@ end:
 	if (port)
 		evdns_close_server_port(port);
 }
+static void
+dns_retry_test(void *arg)
+{
+	dns_retry_test_impl(arg, 0);
+}
+static void
+dns_retry_disable_when_inactive_test(void *arg)
+{
+	dns_retry_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
+}
 
 static struct regress_dns_server_table internal_error_table[] = {
 	/* Error 4 (NOTIMPL) makes us reissue the request to another server
@@ -753,7 +786,7 @@ static struct regress_dns_server_table reissue_table[] = {
 };
 
 static void
-dns_reissue_test(void *arg)
+dns_reissue_test_impl(void *arg, int flags)
 {
 	struct basic_test_data *data = arg;
 	struct event_base *base = data->base;
@@ -772,7 +805,7 @@ dns_reissue_test(void *arg)
 	evutil_snprintf(buf1, sizeof(buf1), "127.0.0.1:%d", (int)portnum1);
 	evutil_snprintf(buf2, sizeof(buf2), "127.0.0.1:%d", (int)portnum2);
 
-	dns = evdns_base_new(base, 0);
+	dns = evdns_base_new(base, flags);
 	tt_assert(!evdns_base_nameserver_ip_add(dns, buf1));
 	tt_assert(! evdns_base_set_option(dns, "timeout:", "0.3"));
 	tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2"));
@@ -805,6 +838,16 @@ end:
 	if (port2)
 		evdns_close_server_port(port2);
 }
+static void
+dns_reissue_test(void *arg)
+{
+	dns_reissue_test_impl(arg, 0);
+}
+static void
+dns_reissue_disable_when_inactive_test(void *arg)
+{
+	dns_reissue_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
+}
 
 #if 0
 static void
@@ -819,21 +862,29 @@ dumb_bytes_fn(char *p, size_t n)
 #endif
 
 static void
-dns_inflight_test(void *arg)
+dns_inflight_test_impl(void *arg, int flags)
 {
 	struct basic_test_data *data = arg;
 	struct event_base *base = data->base;
 	struct evdns_base *dns = NULL;
+	struct evdns_server_port *dns_port = NULL;
 	ev_uint16_t portnum = 0;
 	char buf[64];
+	int disable_when_inactive = flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE;
 
 	struct generic_dns_callback_result r[20];
 	int i;
 
-	tt_assert(regress_dnsserver(base, &portnum, reissue_table));
+	dns_port = regress_get_dnsserver(base, &portnum, NULL,
+		regress_dns_server_cb, reissue_table);
+	tt_assert(dns_port);
+	if (disable_when_inactive) {
+		exit_port = dns_port;
+	}
+
 	evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
 
-	dns = evdns_base_new(base, 0);
+	dns = evdns_base_new(base, flags);
 	tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
 	tt_assert(! evdns_base_set_option(dns, "max-inflight:", "3"));
 	tt_assert(! evdns_base_set_option(dns, "randomize-case:", "0"));
@@ -855,7 +906,65 @@ dns_inflight_test(void *arg)
 end:
 	if (dns)
 		evdns_base_free(dns, 0);
+	if (exit_port) {
+		evdns_close_server_port(exit_port);
+		exit_port = NULL;
+	} else if (! disable_when_inactive) {
+		evdns_close_server_port(dns_port);
+	}
+}
+
+static void
+dns_inflight_test(void *arg)
+{
+	dns_inflight_test_impl(arg, 0);
+}
+
+static void
+dns_disable_when_inactive_test(void *arg)
+{
+	dns_inflight_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
+}
+
+static void
+dns_disable_when_inactive_no_ns_test(void *arg)
+{
+	struct basic_test_data *data = arg;
+	struct event_base *base = data->base, *inactive_base;
+	struct evdns_base *dns = NULL;
+	ev_uint16_t portnum = 0;
+	char buf[64];
+	struct generic_dns_callback_result r;
+
+	inactive_base = event_base_new();
+	tt_assert(inactive_base);
+
+	/** Create dns server with inactive base, to avoid replying to clients */
+	tt_assert(regress_dnsserver(inactive_base, &portnum, search_table));
+	evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
+
+	dns = evdns_base_new(base, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
+	tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
+	tt_assert(! evdns_base_set_option(dns, "timeout:", "0.1"));
+
+	evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r);
+	n_replies_left = 1;
+	exit_base = base;
+
+	event_base_dispatch(base);
+
+	tt_int_op(n_replies_left, ==, 0);
+
+	tt_int_op(r.result, ==, DNS_ERR_TIMEOUT);
+	tt_int_op(r.count, ==, 0);
+	tt_ptr_op(r.addrs, ==, NULL);
+
+end:
+	if (dns)
+		evdns_base_free(dns, 0);
 	regress_clean_dnsserver();
+	if (inactive_base)
+		event_base_free(inactive_base);
 }
 
 /* === Test for bufferevent_socket_connect_hostname */
@@ -1563,7 +1672,8 @@ test_getaddrinfo_async(void *arg)
 end:
 	if (local_outcome.ai)
 		evutil_freeaddrinfo(local_outcome.ai);
-	for (i=0;i<10;++i) {
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+	for (i=0;i<(int)ARRAY_SIZE(a_out);++i) {
 		if (a_out[i].ai)
 			evutil_freeaddrinfo(a_out[i].ai);
 	}
@@ -1694,9 +1804,15 @@ testleak_setup(const struct testcase_t *testcase)
 	struct testleak_env_t *env;
 
 	allocated_chunks = 0;
+
+	/* Reset allocation counter, to start allocations from the very beginning.
+	 * (this will avoid false-positive negative numbers for allocated_chunks)
+	 */
+	libevent_global_shutdown();
+
 	event_set_mem_functions(cnt_malloc, cnt_realloc, cnt_free);
-	if (!libevent_tests_running_in_debug_mode)
-		event_enable_debug_mode();
+
+	event_enable_debug_mode();
 
 	/* not mm_calloc: we don't want to mess with the count. */
 	env = calloc(1, sizeof(struct testleak_env_t));
@@ -1717,8 +1833,8 @@ testleak_cleanup(const struct testcase_t *testcase, void *env_)
 #ifdef EVENT__DISABLE_DEBUG_MODE
 	tt_int_op(allocated_chunks, ==, 0);
 #else
-	/* FIXME: that's `1' because of event_debug_map_HT_GROW */
-	tt_int_op(allocated_chunks, ==, 1);
+	libevent_global_shutdown();
+	tt_int_op(allocated_chunks, ==, 0);
 #endif
 	ok = 1;
 end:
@@ -1791,6 +1907,7 @@ dbg_leak_resume(void *env_, int cancel, int send_err_shutdown)
 end:
 	evdns_base_free(env->dns_base, send_err_shutdown);
 	env->dns_base = 0;
+
 	event_base_free(env->base);
 	env->base = 0;
 }
@@ -1875,6 +1992,8 @@ end:
 		evdns_base_free(dns_base, 1);
 	if (server)
 		evdns_close_server_port(server);
+	if (base)
+		event_base_free(base);
 	if (fd >= 0)
 		evutil_closesocket(fd);
 }
@@ -1894,10 +2013,18 @@ struct testcase_t dns_testcases[] = {
 	{ "search_cancel", dns_search_cancel_test,
 	  TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
 	{ "retry", dns_retry_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
+	{ "retry_disable_when_inactive", dns_retry_disable_when_inactive_test,
+	  TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
 	{ "reissue", dns_reissue_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
+	{ "reissue_disable_when_inactive", dns_reissue_disable_when_inactive_test,
+	  TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
 	{ "inflight", dns_inflight_test, TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
 	{ "bufferevent_connect_hostname", test_bufferevent_connect_hostname,
 	  TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
+	{ "disable_when_inactive", dns_disable_when_inactive_test,
+	  TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
+	{ "disable_when_inactive_no_ns", dns_disable_when_inactive_no_ns_test,
+	  TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
 
 	{ "getaddrinfo_async", test_getaddrinfo_async,
 	  TT_FORK|TT_NEED_BASE, &basic_setup, (char*)"" },
diff --git a/sntp/libevent/test/regress_finalize.c b/sntp/libevent/test/regress_finalize.c
index 61a6313..552210f 100644
--- a/sntp/libevent/test/regress_finalize.c
+++ b/sntp/libevent/test/regress_finalize.c
@@ -25,6 +25,7 @@
  */
 
 #include "event2/event-config.h"
+#include "evconfig-private.h"
 #include "tinytest.h"
 #include "tinytest_macros.h"
 #include <stdlib.h>
diff --git a/sntp/libevent/test/regress_http.c b/sntp/libevent/test/regress_http.c
index ca7d515..35f6dd7 100644
--- a/sntp/libevent/test/regress_http.c
+++ b/sntp/libevent/test/regress_http.c
@@ -105,8 +105,12 @@ http_bind(struct evhttp *myhttp, ev_uint16_t *pport, int ipv6)
 	else
 		sock = evhttp_bind_socket_with_handle(myhttp, "127.0.0.1", *pport);
 
-	if (sock == NULL)
-		event_errx(1, "Could not start web server");
+	if (sock == NULL) {
+		if (ipv6)
+			return -1;
+		else
+			event_errx(1, "Could not start web server");
+	}
 
 	port = regress_get_socket_port(evhttp_bound_socket_get_fd(sock));
 	if (port < 0)
@@ -395,7 +399,7 @@ http_basic_test(void *arg)
 {
 	struct basic_test_data *data = arg;
 	struct timeval tv;
-	struct bufferevent *bev;
+	struct bufferevent *bev = NULL;
 	evutil_socket_t fd;
 	const char *http_request;
 	ev_uint16_t port = 0, port2 = 0;
@@ -480,7 +484,8 @@ http_basic_test(void *arg)
 
 	evhttp_free(http);
  end:
-	;
+	if (bev)
+		bufferevent_free(bev);
 }
 
 
@@ -714,6 +719,7 @@ http_delete_test(void *arg)
 
 	http = http_setup(&port, data->base, 0);
 
+	tt_assert(http);
 	fd = http_connect("127.0.0.1", port);
 	tt_int_op(fd, >=, 0);
 
@@ -734,6 +740,7 @@ http_delete_test(void *arg)
 
 	bufferevent_free(bev);
 	evutil_closesocket(fd);
+	fd = -1;
 
 	evhttp_free(http);
 
@@ -953,7 +960,8 @@ static void http_request_done(struct evhttp_request *, void *);
 static void http_request_empty_done(struct evhttp_request *, void *);
 
 static void
-http_connection_test_(struct basic_test_data *data, int persistent, const char *address, struct evdns_base *dnsbase, int ipv6)
+http_connection_test_(struct basic_test_data *data, int persistent,
+	const char *address, struct evdns_base *dnsbase, int ipv6, int family)
 {
 	ev_uint16_t port = 0;
 	struct evhttp_connection *evcon = NULL;
@@ -962,9 +970,14 @@ http_connection_test_(struct basic_test_data *data, int persistent, const char *
 	test_ok = 0;
 
 	http = http_setup(&port, data->base, ipv6);
+	if (!http && ipv6) {
+		tt_skip();
+	}
+	tt_assert(http);
 
 	evcon = evhttp_connection_base_new(data->base, dnsbase, address, port);
 	tt_assert(evcon);
+	evhttp_connection_set_family(evcon, family);
 
 	tt_assert(evhttp_connection_get_base(evcon) == data->base);
 
@@ -1038,12 +1051,12 @@ http_connection_test_(struct basic_test_data *data, int persistent, const char *
 static void
 http_connection_test(void *arg)
 {
-	http_connection_test_(arg, 0, "127.0.0.1", NULL, 0);
+	http_connection_test_(arg, 0, "127.0.0.1", NULL, 0, AF_UNSPEC);
 }
 static void
 http_persist_connection_test(void *arg)
 {
-	http_connection_test_(arg, 1, "127.0.0.1", NULL, 0);
+	http_connection_test_(arg, 1, "127.0.0.1", NULL, 0, AF_UNSPEC);
 }
 
 static struct regress_dns_server_table search_table[] = {
@@ -1147,6 +1160,63 @@ http_connection_async_test(void *arg)
 }
 
 static void
+http_autofree_connection_test(void *arg)
+{
+	struct basic_test_data *data = arg;
+	ev_uint16_t port = 0;
+	struct evhttp_connection *evcon = NULL;
+	struct evhttp_request *req[2] = { NULL };
+
+	test_ok = 0;
+	http = http_setup(&port, data->base, 0);
+
+	evcon = evhttp_connection_base_new(data->base, NULL, "127.0.0.1", port);
+	tt_assert(evcon);
+
+	/*
+	 * At this point, we want to schedule two request to the HTTP
+	 * server using our make request method.
+	 */
+	req[0] = evhttp_request_new(http_request_empty_done, data->base);
+	req[1] = evhttp_request_new(http_request_empty_done, data->base);
+
+	/* Add the information that we care about */
+	evhttp_add_header(evhttp_request_get_output_headers(req[0]), "Host", "somehost");
+	evhttp_add_header(evhttp_request_get_output_headers(req[0]), "Connection", "close");
+	evhttp_add_header(evhttp_request_get_output_headers(req[0]), "Empty", "itis");
+	evhttp_add_header(evhttp_request_get_output_headers(req[1]), "Host", "somehost");
+	evhttp_add_header(evhttp_request_get_output_headers(req[1]), "Connection", "close");
+	evhttp_add_header(evhttp_request_get_output_headers(req[1]), "Empty", "itis");
+
+	/* We give ownership of the request to the connection */
+	if (evhttp_make_request(evcon, req[0], EVHTTP_REQ_GET, "/test") == -1) {
+		tt_abort_msg("couldn't make request");
+	}
+	if (evhttp_make_request(evcon, req[1], EVHTTP_REQ_GET, "/test") == -1) {
+		tt_abort_msg("couldn't make request");
+	}
+
+	/*
+	 * Tell libevent to free the connection when the request completes
+	 *	We then set the evcon pointer to NULL since we don't want to free it
+	 *	when this function ends.
+	 */
+	evhttp_connection_free_on_completion(evcon);
+	evcon = NULL;
+
+	event_base_dispatch(data->base);
+
+	/* at this point, the http server should have no connection */
+	tt_assert(TAILQ_FIRST(&http->connections) == NULL);
+
+ end:
+	if (evcon)
+		evhttp_connection_free(evcon);
+	if (http)
+		evhttp_free(http);
+}
+
+static void
 http_request_never_call(struct evhttp_request *req, void *arg)
 {
 	fprintf(stdout, "FAILED\n");
@@ -2743,6 +2813,7 @@ http_incomplete_test_(struct basic_test_data *data, int use_timeout)
 	bufferevent_free(bev);
 	if (use_timeout) {
 		evutil_closesocket(fd);
+		fd = -1;
 	}
 
 	evhttp_free(http);
@@ -3748,7 +3819,7 @@ static struct regress_dns_server_table ipv6_search_table[] = {
 };
 
 static void
-http_ipv6_for_domain_test(void *arg)
+http_ipv6_for_domain_test_impl(void *arg, int family)
 {
 	struct basic_test_data *data = arg;
 	struct evdns_base *dns_base = NULL;
@@ -3765,13 +3836,19 @@ http_ipv6_for_domain_test(void *arg)
 	evutil_snprintf(address, sizeof(address), "127.0.0.1:%d", portnum);
 	evdns_base_nameserver_ip_add(dns_base, address);
 
-	http_connection_test_(arg, 0 /* not persistent */, "localhost", dns_base, 1 /* ipv6 */);
+	http_connection_test_(arg, 0 /* not persistent */, "localhost", dns_base,
+		1 /* ipv6 */, family);
 
  end:
 	if (dns_base)
 		evdns_base_free(dns_base, 0);
 	regress_clean_dnsserver();
 }
+static void
+http_ipv6_for_domain_test(void *arg)
+{
+	http_ipv6_for_domain_test_impl(arg, AF_UNSPEC);
+}
 
 static void
 http_request_get_addr_on_close(struct evhttp_connection *evcon, void *arg)
@@ -3836,6 +3913,22 @@ http_get_addr_test(void *arg)
 		evhttp_free(http);
 }
 
+static void
+http_set_family_test(void *arg)
+{
+	http_connection_test_(arg, 0, "127.0.0.1", NULL, 0, AF_UNSPEC);
+}
+static void
+http_set_family_ipv4_test(void *arg)
+{
+	http_connection_test_(arg, 0, "127.0.0.1", NULL, 0, AF_INET);
+}
+static void
+http_set_family_ipv6_test(void *arg)
+{
+	http_ipv6_for_domain_test_impl(arg, AF_INET6);
+}
+
 #define HTTP_LEGACY(name)						\
 	{ #name, run_legacy_test_fn, TT_ISOLATED|TT_LEGACY, &legacy_setup, \
 		    http_##name##_test }
@@ -3861,6 +3954,7 @@ struct testcase_t http_testcases[] = {
 	HTTP(failure),
 	HTTP(connection),
 	HTTP(persist_connection),
+	HTTP(autofree_connection),
 	HTTP(connection_async),
 	HTTP(close_detection),
 	HTTP(close_detection_delay),
@@ -3888,6 +3982,10 @@ struct testcase_t http_testcases[] = {
 	HTTP(ipv6_for_domain),
 	HTTP(get_addr),
 
+	HTTP(set_family),
+	HTTP(set_family_ipv4),
+	HTTP(set_family_ipv6),
+
 	END_OF_TESTCASES
 };
 
diff --git a/sntp/libevent/test/regress_main.c b/sntp/libevent/test/regress_main.c
index 58cbe5f..3198ced 100644
--- a/sntp/libevent/test/regress_main.c
+++ b/sntp/libevent/test/regress_main.c
@@ -90,6 +90,8 @@
 #include "../iocp-internal.h"
 #include "../event-internal.h"
 
+struct evutil_weakrand_state test_weakrand_state;
+
 long
 timeval_msec_diff(const struct timeval *start, const struct timeval *end)
 {
@@ -452,6 +454,8 @@ main(int argc, const char **argv)
 
 	tinytest_set_aliases(testaliases);
 
+	evutil_weakrand_seed_(&test_weakrand_state, 0);
+
 	if (tinytest_main(argc,argv,testgroups))
 		return 1;
 
diff --git a/sntp/libevent/test/regress_minheap.c b/sntp/libevent/test/regress_minheap.c
index a1f554e..05db32e 100644
--- a/sntp/libevent/test/regress_minheap.c
+++ b/sntp/libevent/test/regress_minheap.c
@@ -30,12 +30,13 @@
 
 #include "tinytest.h"
 #include "tinytest_macros.h"
+#include "regress.h"
 
 static void
 set_random_timeout(struct event *ev)
 {
-	ev->ev_timeout.tv_sec = rand();
-	ev->ev_timeout.tv_usec = rand() & 0xfffff;
+	ev->ev_timeout.tv_sec = test_weakrand();
+	ev->ev_timeout.tv_usec = test_weakrand() & 0xfffff;
 	ev->ev_timeout_pos.min_heap_idx = -1;
 }
 
diff --git a/sntp/libevent/test/regress_ssl.c b/sntp/libevent/test/regress_ssl.c
index c211341..bf9b46b 100644
--- a/sntp/libevent/test/regress_ssl.c
+++ b/sntp/libevent/test/regress_ssl.c
@@ -194,6 +194,7 @@ respond_to_number(struct bufferevent *bev, void *ctx)
 	n = atoi(line);
 	if (n <= 0)
 		TT_FAIL(("Bad number: %s", line));
+	free(line);
 	TT_BLATHER(("The number was %d", n));
 	if (n == 1001) {
 		++test_is_done;
diff --git a/sntp/libevent/test/regress_thread.c b/sntp/libevent/test/regress_thread.c
index 612bf1d..c42668e 100644
--- a/sntp/libevent/test/regress_thread.c
+++ b/sntp/libevent/test/regress_thread.c
@@ -361,7 +361,7 @@ thread_conditions_simple(void *arg)
 			    &tv_signal);
 			diff2 = timeval_msec_diff(&actual_delay,
 			    &tv_broadcast);
-			if (abs(diff1) < abs(diff2)) {
+			if (labs(diff1) < labs(diff2)) {
 				TT_BLATHER(("%d looks like a signal\n", i));
 				target_delay = &tv_signal;
 				++n_signal;
@@ -382,7 +382,8 @@ thread_conditions_simple(void *arg)
 	tt_int_op(n_signal, ==, 1);
 
 end:
-	;
+	EVTHREAD_FREE_LOCK(cond.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
+	EVTHREAD_FREE_COND(cond.cond);
 }
 
 #define CB_COUNT 128
diff --git a/sntp/libevent/test/regress_util.c b/sntp/libevent/test/regress_util.c
index d64d002..60f085b 100644
--- a/sntp/libevent/test/regress_util.c
+++ b/sntp/libevent/test/regress_util.c
@@ -179,10 +179,10 @@ regress_ipv6_parse(void *ptr)
 		for (j = 0; j < 4; ++j) {
 			/* Can't use s6_addr32 here; some don't have it. */
 			ev_uint32_t u =
-				(in6.s6_addr[j*4  ] << 24) |
-				(in6.s6_addr[j*4+1] << 16) |
-				(in6.s6_addr[j*4+2] << 8) |
-				(in6.s6_addr[j*4+3]);
+			    ((ev_uint32_t)in6.s6_addr[j*4  ] << 24) |
+			    ((ev_uint32_t)in6.s6_addr[j*4+1] << 16) |
+			    ((ev_uint32_t)in6.s6_addr[j*4+2] << 8) |
+			    ((ev_uint32_t)in6.s6_addr[j*4+3]);
 			if (u != ent->res[j]) {
 				TT_FAIL(("%s did not parse as expected.", ent->addr));
 				continue;
@@ -726,46 +726,48 @@ test_evutil_integers(void *arg)
 	tt_assert(u64 > 0);
 	tt_assert(i64 > 0);
 	u64++;
-	i64++;
+/*	i64++; */
 	tt_assert(u64 == 0);
-	tt_assert(i64 == EV_INT64_MIN);
-	tt_assert(i64 < 0);
+/*	tt_assert(i64 == EV_INT64_MIN); */
+/*	tt_assert(i64 < 0); */
 
 	u32 = EV_UINT32_MAX;
 	i32 = EV_INT32_MAX;
 	tt_assert(u32 > 0);
 	tt_assert(i32 > 0);
 	u32++;
-	i32++;
+/*	i32++; */
 	tt_assert(u32 == 0);
-	tt_assert(i32 == EV_INT32_MIN);
-	tt_assert(i32 < 0);
+/*	tt_assert(i32 == EV_INT32_MIN); */
+/*	tt_assert(i32 < 0); */
 
 	u16 = EV_UINT16_MAX;
 	i16 = EV_INT16_MAX;
 	tt_assert(u16 > 0);
 	tt_assert(i16 > 0);
 	u16++;
-	i16++;
+/*	i16++; */
 	tt_assert(u16 == 0);
-	tt_assert(i16 == EV_INT16_MIN);
-	tt_assert(i16 < 0);
+/*	tt_assert(i16 == EV_INT16_MIN); */
+/* 	tt_assert(i16 < 0); */
 
 	u8 = EV_UINT8_MAX;
 	i8 = EV_INT8_MAX;
 	tt_assert(u8 > 0);
 	tt_assert(i8 > 0);
 	u8++;
-	i8++;
+/*	i8++;*/
 	tt_assert(u8 == 0);
-	tt_assert(i8 == EV_INT8_MIN);
-	tt_assert(i8 < 0);
+/*	tt_assert(i8 == EV_INT8_MIN); */
+/*	tt_assert(i8 < 0); */
 
+/*
 	ssize = EV_SSIZE_MAX;
 	tt_assert(ssize > 0);
 	ssize++;
 	tt_assert(ssize < 0);
 	tt_assert(ssize == EV_SSIZE_MIN);
+*/
 
 	ptr = &ssize;
 	iptr = (ev_intptr_t)ptr;
@@ -1119,7 +1121,7 @@ end:
 static void
 test_evutil_loadsyslib(void *arg)
 {
-	HANDLE h=NULL;
+	HMODULE h=NULL;
 
 	h = evutil_load_windows_system_library_(TEXT("kernel32.dll"));
 	tt_assert(h);
diff --git a/sntp/libevent/test/regress_zlib.c b/sntp/libevent/test/regress_zlib.c
index 9339397..8406676 100644
--- a/sntp/libevent/test/regress_zlib.c
+++ b/sntp/libevent/test/regress_zlib.c
@@ -56,6 +56,7 @@
 #include "event2/bufferevent.h"
 
 #include "regress.h"
+#include "mm-internal.h"
 
 /* zlib 1.2.4 and 1.2.5 do some "clever" things with macros.  Instead of
    saying "(defined(FOO) ? FOO : 0)" they like to say "FOO-0", on the theory
@@ -95,6 +96,7 @@ zlib_deflate_free(void *ctx)
 	z_streamp p = ctx;
 
 	assert(deflateEnd(p) == Z_OK);
+	mm_free(p);
 }
 
 static void
@@ -103,6 +105,7 @@ zlib_inflate_free(void *ctx)
 	z_streamp p = ctx;
 
 	assert(inflateEnd(p) == Z_OK);
+	mm_free(p);
 }
 
 static int
@@ -275,7 +278,7 @@ test_bufferevent_zlib(void *arg)
 {
 	struct bufferevent *bev1=NULL, *bev2=NULL;
 	char buffer[8333];
-	z_stream z_input, z_output;
+	z_stream *z_input, *z_output;
 	int i, r;
 	evutil_socket_t pair[2] = {-1, -1};
 	(void)arg;
@@ -293,18 +296,18 @@ test_bufferevent_zlib(void *arg)
 	bev1 = bufferevent_socket_new(NULL, pair[0], 0);
 	bev2 = bufferevent_socket_new(NULL, pair[1], 0);
 
-	memset(&z_output, 0, sizeof(z_output));
-	r = deflateInit(&z_output, Z_DEFAULT_COMPRESSION);
+	z_output = mm_calloc(sizeof(*z_output), 1);
+	r = deflateInit(z_output, Z_DEFAULT_COMPRESSION);
 	tt_int_op(r, ==, Z_OK);
-	memset(&z_input, 0, sizeof(z_input));
-	r = inflateInit(&z_input);
+	z_input = mm_calloc(sizeof(*z_input), 1);
+	r = inflateInit(z_input);
 	tt_int_op(r, ==, Z_OK);
 
 	/* initialize filters */
 	bev1 = bufferevent_filter_new(bev1, NULL, zlib_output_filter,
-	    BEV_OPT_CLOSE_ON_FREE, zlib_deflate_free, &z_output);
+	    BEV_OPT_CLOSE_ON_FREE, zlib_deflate_free, z_output);
 	bev2 = bufferevent_filter_new(bev2, zlib_input_filter,
-	    NULL, BEV_OPT_CLOSE_ON_FREE, zlib_inflate_free, &z_input);
+	    NULL, BEV_OPT_CLOSE_ON_FREE, zlib_inflate_free, z_input);
 	bufferevent_setcb(bev1, readcb, writecb, errorcb, NULL);
 	bufferevent_setcb(bev2, readcb, writecb, errorcb, NULL);
 
diff --git a/sntp/libevent/test/test-fdleak.c b/sntp/libevent/test/test-fdleak.c
index ee2432b..4c4eba2 100644
--- a/sntp/libevent/test/test-fdleak.c
+++ b/sntp/libevent/test/test-fdleak.c
@@ -57,7 +57,7 @@
 #endif
 
 /* Provide storage for the address, both for the server & the clients */
-static struct sockaddr_in sin;
+static struct sockaddr_in saddr;
 
 /* Number of sucessful requests so far */
 static int num_requests;
@@ -131,7 +131,7 @@ start_loop(void)
 
 	listener = evconnlistener_new_bind(base, listener_accept_cb, NULL,
 	    LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
-	    -1, (struct sockaddr *)&sin, sizeof(sin));
+	    -1, (struct sockaddr *)&saddr, sizeof(saddr));
 	if (listener == NULL) {
 		my_perror("Could not create listener!");
 		exit(1);
@@ -145,8 +145,8 @@ start_loop(void)
 		my_perror("getsockname()");
 		exit(1);
 	}
-	memcpy(&sin, &ss, sizeof(sin));
-	if (sin.sin_family != AF_INET) {
+	memcpy(&saddr, &ss, sizeof(saddr));
+	if (saddr.sin_family != AF_INET) {
 		puts("AF mismatch from getsockname().");
 		exit(1);
 	}
@@ -208,8 +208,8 @@ start_client(struct event_base *base)
                                                          BEV_OPT_CLOSE_ON_FREE);
 	bufferevent_setcb(bev, client_read_cb, NULL, client_event_cb, NULL);
 
-	if (bufferevent_socket_connect(bev, (struct sockaddr *)&sin,
-                                       sizeof(sin)) < 0) {
+	if (bufferevent_socket_connect(bev, (struct sockaddr *)&saddr,
+                                       sizeof(saddr)) < 0) {
 		my_perror("Could not connect!");
 		bufferevent_free(bev);
 		exit(2);
@@ -236,10 +236,10 @@ main(int argc, char **argv)
 #endif
 
 	/* Set up an address, used by both client & server. */
-	memset(&sin, 0, sizeof(sin));
-	sin.sin_family = AF_INET;
-	sin.sin_addr.s_addr = htonl(0x7f000001);
-	sin.sin_port = 0; /* Tell the implementation to pick a port. */
+	memset(&saddr, 0, sizeof(saddr));
+	saddr.sin_family = AF_INET;
+	saddr.sin_addr.s_addr = htonl(0x7f000001);
+	saddr.sin_port = 0; /* Tell the implementation to pick a port. */
 
 	start_loop();
 
diff --git a/sntp/libevent/test/test-ratelim.c b/sntp/libevent/test/test-ratelim.c
index 27649b8..17babfd 100644
--- a/sntp/libevent/test/test-ratelim.c
+++ b/sntp/libevent/test/test-ratelim.c
@@ -50,6 +50,7 @@
 #include "event2/listener.h"
 #include "event2/thread.h"
 
+static struct evutil_weakrand_state weakrand_state;
 
 static int cfg_verbose = 0;
 static int cfg_help = 0;
@@ -113,11 +114,7 @@ loud_writecb(struct bufferevent *bev, void *ctx)
 	struct client_state *cs = ctx;
 	struct evbuffer *output = bufferevent_get_output(bev);
 	char buf[1024];
-#ifdef _WIN32
-	int r = rand() % 256;
-#else
-	int r = random() % 256;
-#endif
+	int r = evutil_weakrand_(&weakrand_state);
 	memset(buf, r, sizeof(buf));
 	while (evbuffer_get_length(output) < 8192) {
 		evbuffer_add(output, buf, sizeof(buf));
@@ -223,7 +220,7 @@ check_bucket_levels_cb(evutil_socket_t fd, short events, void *arg)
 #undef B
 
 	total_n_bev_checks++;
-	if (total_n_bev_checks >= .8 * (cfg_duration / cfg_tick_msec) * cfg_n_connections) {
+	if (total_n_bev_checks >= .8 * ((double)cfg_duration / cfg_tick_msec) * cfg_n_connections) {
 		event_free(event_base_get_running_event(bufferevent_get_base(bev)));
 	}
 }
@@ -553,6 +550,8 @@ main(int argc, char **argv)
 	(void) WSAStartup(wVersionRequested, &wsaData);
 #endif
 
+	evutil_weakrand_seed_(&weakrand_state, 0);
+
 #ifndef _WIN32
 	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
 		return 1;
diff --git a/sntp/libevent/test/test-time.c b/sntp/libevent/test/test-time.c
index dcd6639..bcc7086 100644
--- a/sntp/libevent/test/test-time.c
+++ b/sntp/libevent/test/test-time.c
@@ -41,6 +41,7 @@
 #include "event2/event.h"
 #include "event2/event_compat.h"
 #include "event2/event_struct.h"
+#include "util-internal.h"
 
 int called = 0;
 
@@ -48,14 +49,12 @@ int called = 0;
 
 struct event *ev[NEVENT];
 
+struct evutil_weakrand_state weakrand_state;
+
 static int
 rand_int(int n)
 {
-#ifdef _WIN32
-	return (int)(rand() % n);
-#else
-	return (int)(random() % n);
-#endif
+	return evutil_weakrand_(&weakrand_state) % n;
 }
 
 static void
@@ -71,7 +70,7 @@ time_cb(evutil_socket_t fd, short event, void *arg)
 			j = rand_int(NEVENT);
 			tv.tv_sec = 0;
 			tv.tv_usec = rand_int(50000);
-			if (tv.tv_usec % 2)
+			if (tv.tv_usec % 2 || called < NEVENT)
 				evtimer_add(ev[j], &tv);
 			else
 				evtimer_del(ev[j]);
@@ -93,6 +92,8 @@ main(int argc, char **argv)
 	(void) WSAStartup(wVersionRequested, &wsaData);
 #endif
 
+	evutil_weakrand_seed_(&weakrand_state, 0);
+
 	/* Initalize the event library */
 	event_init();
 
@@ -108,6 +109,8 @@ main(int argc, char **argv)
 
 	event_dispatch();
 
+
+	printf("%d, %d\n", called, NEVENT);
 	return (called < NEVENT);
 }
 
diff --git a/sntp/libevent/test/tinytest.c b/sntp/libevent/test/tinytest.c
index 36b3a62..3a8e331 100644
--- a/sntp/libevent/test/tinytest.c
+++ b/sntp/libevent/test/tinytest.c
@@ -31,6 +31,8 @@
 #include <string.h>
 #include <assert.h>
 
+#ifndef NO_FORKING
+
 #ifdef _WIN32
 #include <windows.h>
 #else
@@ -48,6 +50,8 @@
 #endif
 #endif
 
+#endif /* !NO_FORKING */
+
 #ifndef __GNUC__
 #define __attribute__(x)
 #endif
@@ -111,6 +115,8 @@ testcase_run_bare_(const struct testcase_t *testcase)
 
 #define MAGIC_EXITCODE 42
 
+#ifndef NO_FORKING
+
 static enum outcome
 testcase_run_forked_(const struct testgroup_t *group,
 		     const struct testcase_t *testcase)
@@ -211,6 +217,8 @@ testcase_run_forked_(const struct testgroup_t *group,
 #endif
 }
 
+#endif /* !NO_FORKING */
+
 int
 testcase_run_one(const struct testgroup_t *group,
 		 const struct testcase_t *testcase)
@@ -234,9 +242,13 @@ testcase_run_one(const struct testgroup_t *group,
 		cur_test_name = testcase->name;
 	}
 
+#ifndef NO_FORKING
 	if ((testcase->flags & TT_FORK) && !(opt_forked||opt_nofork)) {
 		outcome = testcase_run_forked_(group, testcase);
 	} else {
+#else
+	{
+#endif
 		outcome = testcase_run_bare_(testcase);
 	}
 
@@ -411,7 +423,9 @@ tinytest_main(int c, const char **v, struct testgroup_t *groups)
 	if (!n)
 		tinytest_set_flag_(groups, "..", 1, TT_ENABLED_);
 
+#ifdef _IONBF
 	setvbuf(stdout, NULL, _IONBF, 0);
+#endif
 
 	++in_tinytest_main;
 	for (i=0; groups[i].prefix; ++i)
@@ -458,3 +472,22 @@ tinytest_set_test_skipped_(void)
 		cur_test_outcome = SKIP;
 }
 
+char *
+tinytest_format_hex_(const void *val_, unsigned long len)
+{
+	const unsigned char *val = val_;
+	char *result, *cp;
+	size_t i;
+
+	if (!val)
+		return strdup("null");
+	if (!(result = malloc(len*2+1)))
+		return strdup("<allocation failure>");
+	cp = result;
+	for (i=0;i<len;++i) {
+		*cp++ = "0123456789ABCDEF"[val[i] >> 4];
+		*cp++ = "0123456789ABCDEF"[val[i] & 0x0f];
+	}
+	*cp = 0;
+	return result;
+}
diff --git a/sntp/libevent/test/tinytest.h b/sntp/libevent/test/tinytest.h
index dff440e..ed07b26 100644
--- a/sntp/libevent/test/tinytest.h
+++ b/sntp/libevent/test/tinytest.h
@@ -81,6 +81,8 @@ int tinytest_get_verbosity_(void);
 /** Implementation: Set a flag on tests matching a name; returns number
  * of tests that matched. */
 int tinytest_set_flag_(struct testgroup_t *, const char *, int set, unsigned long);
+/** Implementation: Put a chunk of memory into hex. */
+char *tinytest_format_hex_(const void *, unsigned long);
 
 /** Set all tests in 'groups' matching the name 'named' to be skipped. */
 #define tinytest_skip(groups, named) \
diff --git a/sntp/libevent/test/tinytest_macros.h b/sntp/libevent/test/tinytest_macros.h
index 9ff69b1..c3728d1 100644
--- a/sntp/libevent/test/tinytest_macros.h
+++ b/sntp/libevent/test/tinytest_macros.h
@@ -113,8 +113,8 @@
 #define tt_assert_test_fmt_type(a,b,str_test,type,test,printf_type,printf_fmt, \
     setup_block,cleanup_block,die_on_fail)				\
 	TT_STMT_BEGIN							\
-	type val1_ = (type)(a);						\
-	type val2_ = (type)(b);						\
+	type val1_ = (a);						\
+	type val2_ = (b);						\
 	int tt_status_ = (test);					\
 	if (!tt_status_ || tinytest_get_verbosity_()>1)	{		\
 		printf_type print_;					\
@@ -144,6 +144,10 @@
 	tt_assert_test_fmt_type(a,b,str_test,type,test,type,fmt,	\
 	    {print_=value_;},{},die_on_fail)
 
+#define tt_assert_test_type_opt(a,b,str_test,type,test,fmt,die_on_fail)	\
+	tt_assert_test_fmt_type(a,b,str_test,type,test,type,fmt,	\
+            {print_=value_?value_:"<NULL>";},{},die_on_fail)
+
 /* Helper: assert that a op b, when cast to type.  Format the values with
  * printf format fmt on failure. */
 #define tt_assert_op_type(a,op,b,type,fmt)				\
@@ -159,12 +163,23 @@
 	    (val1_ op val2_),"%lu",TT_EXIT_TEST_FUNCTION)
 
 #define tt_ptr_op(a,op,b)						\
-	tt_assert_test_type(a,b,#a" "#op" "#b,void*,			\
+	tt_assert_test_type(a,b,#a" "#op" "#b,const void*,              \
 	    (val1_ op val2_),"%p",TT_EXIT_TEST_FUNCTION)
 
 #define tt_str_op(a,op,b)						\
-	tt_assert_test_type(a,b,#a" "#op" "#b,const char *,		\
-	    (strcmp(val1_,val2_) op 0),"<%s>",TT_EXIT_TEST_FUNCTION)
+	tt_assert_test_type_opt(a,b,#a" "#op" "#b,const char *,		\
+	    (val1_ && val2_ && strcmp(val1_,val2_) op 0),"<%s>",	\
+	    TT_EXIT_TEST_FUNCTION)
+
+#define tt_mem_op(expr1, op, expr2, len)                                \
+  tt_assert_test_fmt_type(expr1,expr2,#expr1" "#op" "#expr2,            \
+			  const void *,                                 \
+			  (val1_ && val2_ && memcmp(val1_, val2_, len) op 0), \
+			  char *, "%s",					\
+			  { print_ = tinytest_format_hex_(value_, (len)); }, \
+			  { if (print_) free(print_); },		\
+			  TT_EXIT_TEST_FUNCTION				\
+                          );
 
 #define tt_want_int_op(a,op,b)						\
 	tt_assert_test_type(a,b,#a" "#op" "#b,long,(val1_ op val2_),"%ld",(void)0)
@@ -174,7 +189,7 @@
 	    (val1_ op val2_),"%lu",(void)0)
 
 #define tt_want_ptr_op(a,op,b)						\
-	tt_assert_test_type(a,b,#a" "#op" "#b,void*,			\
+  tt_assert_test_type(a,b,#a" "#op" "#b,const void*,			\
 	    (val1_ op val2_),"%p",(void)0)
 
 #define tt_want_str_op(a,op,b)						\