1 files changed, 325 insertions, 66 deletions

diff --git a/test/regress_ssl.c b/test/regress_ssl.c
index 681705fc..68c28114 100644
--- a/test/regress_ssl.c
+++ b/test/regress_ssl.c
@@ -53,7 +53,6 @@
 #include "tinytest.h"
 #include "tinytest_macros.h"
 
-#include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
 #include "openssl-compat.h"
@@ -119,14 +118,13 @@ end:
 }
 
 X509 *
-ssl_getcert(void)
+ssl_getcert(EVP_PKEY *key)
 {
 	/* Dummy code to make a quick-and-dirty valid certificate with
 	   OpenSSL.  Don't copy this code into your own program! It does a
 	   number of things in a stupid and insecure way. */
 	X509 *x509 = NULL;
 	X509_NAME *name = NULL;
-	EVP_PKEY *key = ssl_getkey();
 	int nid;
 	time_t now = time(NULL);
 
@@ -148,6 +146,7 @@ ssl_getcert(void)
 
 	X509_set_subject_name(x509, name);
 	X509_set_issuer_name(x509, name);
+	X509_NAME_free(name);
 
 	X509_time_adj(X509_get_notBefore(x509), 0, &now);
 	now += 3600;
@@ -158,6 +157,7 @@ ssl_getcert(void)
 	return x509;
 end:
 	X509_free(x509);
+	X509_NAME_free(name);
 	return NULL;
 }
 
@@ -183,35 +183,86 @@ get_ssl_ctx(void)
 	return the_ssl_ctx;
 }
 
+static int test_is_done;
+static int n_connected;
+static int got_close;
+static int got_error;
+static int got_timeout;
+static int renegotiate_at = -1;
+static int stop_when_connected;
+static int pending_connect_events;
+static struct event_base *exit_base;
+static X509 *the_cert;
+EVP_PKEY *the_key;
+
 void
 init_ssl(void)
 {
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L) || \
+	(defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
 	SSL_library_init();
 	ERR_load_crypto_strings();
 	SSL_load_error_strings();
 	OpenSSL_add_all_algorithms();
 	if (SSLeay() != OPENSSL_VERSION_NUMBER) {
-		TT_DECLARE("WARN", ("Version mismatch for openssl: compiled with %lx but running with %lx", (unsigned long)OPENSSL_VERSION_NUMBER, (unsigned long) SSLeay()));
+		TT_DECLARE("WARN",
+			("Version mismatch for openssl: compiled with %lx but running with %lx",
+			(unsigned long)OPENSSL_VERSION_NUMBER, (unsigned long)SSLeay()));
 	}
 #endif
 }
 
+static void *
+ssl_test_setup(const struct testcase_t *testcase)
+{
+	init_ssl();
+
+	the_key = ssl_getkey();
+	EVUTIL_ASSERT(the_key);
+
+	the_cert = ssl_getcert(the_key);
+	EVUTIL_ASSERT(the_cert);
+
+	disable_tls_11_and_12 = 0;
+
+	return basic_test_setup(testcase);
+}
+static int
+ssl_test_cleanup(const struct testcase_t *testcase, void *ptr)
+{
+	int ret = basic_test_cleanup(testcase, ptr);
+	if (!ret) {
+		return ret;
+	}
+
+	test_is_done = 0;
+	n_connected = 0;
+	got_close = 0;
+	got_error = 0;
+	got_timeout = 0;
+	renegotiate_at = -1;
+	stop_when_connected = 0;
+	pending_connect_events = 0;
+	exit_base = NULL;
+
+	X509_free(the_cert);
+	EVP_PKEY_free(the_key);
+
+	SSL_CTX_free(the_ssl_ctx);
+	the_ssl_ctx = NULL;
+
+	return 1;
+}
+const struct testcase_setup_t ssl_setup = {
+	ssl_test_setup, ssl_test_cleanup
+};
+
+
 /* ====================
    Here's a simple test: we read a number from the input, increment it, and
    reply, until we get to 1001.
 */
 
-static int test_is_done = 0;
-static int n_connected = 0;
-static int got_close = 0;
-static int got_error = 0;
-static int got_timeout = 0;
-static int renegotiate_at = -1;
-static int stop_when_connected = 0;
-static int pending_connect_events = 0;
-static struct event_base *exit_base = NULL;
-
 enum regress_openssl_type
 {
 	REGRESS_OPENSSL_SOCKETPAIR = 1,
@@ -229,17 +280,19 @@ enum regress_openssl_type
 	REGRESS_OPENSSL_SLEEP = 1024,
 
 	REGRESS_OPENSSL_CLIENT_WRITE = 2048,
+
+	REGRESS_DEFERRED_CALLBACKS = 4096,
 };
 
 static void
 bufferevent_openssl_check_fd(struct bufferevent *bev, int filter)
 {
-	tt_int_op(bufferevent_getfd(bev), !=, -1);
-	tt_int_op(bufferevent_setfd(bev, -1), ==, 0);
+	tt_fd_op(bufferevent_getfd(bev), !=, EVUTIL_INVALID_SOCKET);
+	tt_fd_op(bufferevent_setfd(bev, EVUTIL_INVALID_SOCKET), ==, 0);
 	if (filter) {
-		tt_int_op(bufferevent_getfd(bev), !=, -1);
+		tt_fd_op(bufferevent_getfd(bev), !=, EVUTIL_INVALID_SOCKET);
 	} else {
-		tt_int_op(bufferevent_getfd(bev), ==, -1);
+		tt_fd_op(bufferevent_getfd(bev), ==, EVUTIL_INVALID_SOCKET);
 	}
 
 end:
@@ -256,6 +309,13 @@ end:
 }
 
 static void
+free_on_cb(struct bufferevent *bev, void *ctx)
+{
+	TT_BLATHER(("free_on_cb: %p", bev));
+	bufferevent_free(bev);
+}
+
+static void
 respond_to_number(struct bufferevent *bev, void *ctx)
 {
 	struct evbuffer *b = bufferevent_get_input(bev);
@@ -303,13 +363,14 @@ done_writing_cb(struct bufferevent *bev, void *ctx)
 static void
 eventcb(struct bufferevent *bev, short what, void *ctx)
 {
+	X509 *peer_cert = NULL;
 	enum regress_openssl_type type;
+
 	type = (enum regress_openssl_type)ctx;
 
 	TT_BLATHER(("Got event %d", (int)what));
 	if (what & BEV_EVENT_CONNECTED) {
 		SSL *ssl;
-		X509 *peer_cert;
 		++n_connected;
 		ssl = bufferevent_openssl_get_ssl(bev);
 		tt_assert(ssl);
@@ -357,8 +418,10 @@ eventcb(struct bufferevent *bev, short what, void *ctx)
 		}
 		bufferevent_free(bev);
 	}
+
 end:
-	;
+	if (peer_cert)
+		X509_free(peer_cert);
 }
 
 static void
@@ -398,8 +461,6 @@ regress_bufferevent_openssl(void *arg)
 
 	struct bufferevent *bev1, *bev2;
 	SSL *ssl1, *ssl2;
-	X509 *cert = ssl_getcert();
-	EVP_PKEY *key = ssl_getkey();
 	int flags = BEV_OPT_DEFER_CALLBACKS;
 	struct bufferevent *bev_ll[2] = { NULL, NULL };
 	evutil_socket_t *fd_pair = NULL;
@@ -407,11 +468,6 @@ regress_bufferevent_openssl(void *arg)
 	enum regress_openssl_type type;
 	type = (enum regress_openssl_type)data->setup_data;
 
-	tt_assert(cert);
-	tt_assert(key);
-
-	init_ssl();
-
 	if (type & REGRESS_OPENSSL_RENEGOTIATE) {
 		if (SSLeay() >= 0x10001000 &&
 		    SSLeay() <  0x1000104f) {
@@ -425,8 +481,8 @@ regress_bufferevent_openssl(void *arg)
 	ssl1 = SSL_new(get_ssl_ctx());
 	ssl2 = SSL_new(get_ssl_ctx());
 
-	SSL_use_certificate(ssl2, cert);
-	SSL_use_PrivateKey(ssl2, key);
+	SSL_use_certificate(ssl2, the_cert);
+	SSL_use_PrivateKey(ssl2, the_key);
 
 	if (!(type & REGRESS_OPENSSL_OPEN))
 		flags |= BEV_OPT_CLOSE_ON_FREE;
@@ -445,7 +501,7 @@ regress_bufferevent_openssl(void *arg)
 	    fd_pair, bev_ll, type);
 
 	if (!(type & REGRESS_OPENSSL_FILTER)) {
-		tt_int_op(bufferevent_getfd(bev1), ==, data->pair[0]);
+		tt_fd_op(bufferevent_getfd(bev1), ==, data->pair[0]);
 	} else {
 		tt_ptr_op(bufferevent_get_underlying(bev1), ==, bev_ll[0]);
 	}
@@ -504,7 +560,10 @@ regress_bufferevent_openssl(void *arg)
 		tt_int_op(got_close, ==, 0);
 		tt_int_op(got_error, ==, 0);
 		tt_int_op(got_timeout, ==, 1);
+
+		bufferevent_free(bev2);
 	}
+
 end:
 	return;
 }
@@ -526,15 +585,13 @@ acceptcb(struct evconnlistener *listener, evutil_socket_t fd,
 
 	type = (enum regress_openssl_type)data->setup_data;
 
-	SSL_use_certificate(ssl, ssl_getcert());
-	SSL_use_PrivateKey(ssl, ssl_getkey());
+	SSL_use_certificate(ssl, the_cert);
+	SSL_use_PrivateKey(ssl, the_key);
 
 	bev = bufferevent_openssl_socket_new(
-		data->base,
-		fd,
-		ssl,
-		BUFFEREVENT_SSL_ACCEPTING,
+		data->base, fd, ssl, BUFFEREVENT_SSL_ACCEPTING,
 		BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
+	tt_assert(bev);
 
 	bufferevent_setcb(bev, respond_to_number, NULL, eventcb,
 	    (void*)(REGRESS_OPENSSL_SERVER));
@@ -550,11 +607,14 @@ acceptcb(struct evconnlistener *listener, evutil_socket_t fd,
 
 	/* Only accept once, then disable ourself. */
 	evconnlistener_disable(listener);
+
+end:
+	;
 }
 
 struct rwcount
 {
-	int fd;
+	evutil_socket_t fd;
 	size_t read;
 	size_t write;
 };
@@ -568,6 +628,7 @@ bio_rwcount_new(BIO *b)
 static int
 bio_rwcount_free(BIO *b)
 {
+	TT_BLATHER(("bio_rwcount_free: %p", b));
 	if (!b)
 		return 0;
 	if (BIO_get_shutdown(b)) {
@@ -590,7 +651,6 @@ bio_rwcount_read(BIO *b, char *out, int outlen)
 static int
 bio_rwcount_write(BIO *b, const char *in, int inlen)
 {
-
 	struct rwcount *rw = BIO_get_data(b);
 	ev_ssize_t ret = send(rw->fd, in, inlen, 0);
 	++rw->write;
@@ -602,8 +662,12 @@ bio_rwcount_write(BIO *b, const char *in, int inlen)
 static long
 bio_rwcount_ctrl(BIO *b, int cmd, long num, void *ptr)
 {
+	struct rwcount *rw = BIO_get_data(b);
 	long ret = 0;
 	switch (cmd) {
+	case BIO_C_GET_FD:
+		ret = rw->fd;
+		break;
 	case BIO_CTRL_GET_CLOSE:
 		ret = BIO_get_shutdown(b);
 		break;
@@ -672,14 +736,11 @@ regress_bufferevent_openssl_connect(void *arg)
 	struct sockaddr_storage ss;
 	ev_socklen_t slen;
 	SSL *ssl;
-	BIO *bio;
 	struct rwcount rw = { -1, 0, 0 };
 	enum regress_openssl_type type;
 
 	type = (enum regress_openssl_type)data->setup_data;
 
-	init_ssl();
-
 	memset(&sin, 0, sizeof(sin));
 	sin.sin_family = AF_INET;
 	sin.sin_addr.s_addr = htonl(0x7f000001);
@@ -703,7 +764,7 @@ regress_bufferevent_openssl_connect(void *arg)
 		BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
 	tt_assert(bev);
 
-	bufferevent_setcb(bev, respond_to_number, NULL, eventcb,
+	bufferevent_setcb(bev, respond_to_number, free_on_cb, eventcb,
 	    (void*)(REGRESS_OPENSSL_CLIENT));
 
 	tt_assert(getsockname(evconnlistener_get_fd(listener),
@@ -716,6 +777,8 @@ regress_bufferevent_openssl_connect(void *arg)
 	/* Possible only when we have fd, since be_openssl can and will overwrite
 	 * bio otherwise before */
 	if (type & REGRESS_OPENSSL_SLEEP) {
+		BIO *bio;
+
 		rw.fd = bufferevent_getfd(bev);
 		bio = BIO_new_rwcount(0);
 		tt_assert(bio);
@@ -730,83 +793,279 @@ regress_bufferevent_openssl_connect(void *arg)
 	tt_int_op(rw.read, <=, 100);
 	tt_int_op(rw.write, <=, 100);
 end:
-	;
+	evconnlistener_free(listener);
+}
+
+struct wm_context
+{
+	int server;
+	int flags;
+	struct evbuffer *data;
+	size_t to_read;
+	size_t wm_high;
+	size_t limit;
+	size_t get;
+	struct bufferevent *bev;
+	struct wm_context *neighbour;
+};
+static void
+wm_transfer(struct bufferevent *bev, void *arg)
+{
+	struct wm_context *ctx = arg;
+	struct evbuffer *in  = bufferevent_get_input(bev);
+	struct evbuffer *out = bufferevent_get_output(bev);
+	size_t len = evbuffer_get_length(in);
+	size_t drain = len < ctx->to_read ? len : ctx->to_read;
+
+	if (ctx->get >= ctx->limit) {
+		TT_BLATHER(("wm_transfer-%s(%p): break",
+			ctx->server ? "server" : "client", bev));
+		bufferevent_setcb(bev, NULL, NULL, NULL, NULL);
+		bufferevent_disable(bev, EV_READ);
+		if (ctx->neighbour->get >= ctx->neighbour->limit) {
+			event_base_loopbreak(bufferevent_get_base(bev));
+		}
+	} else {
+		ctx->get += drain;
+		evbuffer_drain(in, drain);
+	}
+
+	TT_BLATHER(("wm_transfer-%s(%p): "
+		"in: " EV_SIZE_FMT ", "
+		"out: " EV_SIZE_FMT ", "
+		"got: " EV_SIZE_FMT "",
+		ctx->server ? "server" : "client", bev,
+		evbuffer_get_length(in),
+		evbuffer_get_length(out),
+		ctx->get));
+
+	evbuffer_add_buffer_reference(out, ctx->data);
+}
+static void
+wm_eventcb(struct bufferevent *bev, short what, void *arg)
+{
+	struct wm_context *ctx = arg;
+	TT_BLATHER(("wm_eventcb-%s(%p): %i",
+		ctx->server ? "server" : "client", bev, what));
+	if (what & BEV_EVENT_CONNECTED) {
+	} else {
+		ctx->get = 0;
+	}
+}
+static void
+wm_acceptcb(struct evconnlistener *listener, evutil_socket_t fd,
+    struct sockaddr *addr, int socklen, void *arg)
+{
+	struct wm_context *ctx = arg;
+	struct bufferevent *bev;
+	struct event_base *base = evconnlistener_get_base(listener);
+	SSL *ssl = SSL_new(get_ssl_ctx());
+
+	SSL_use_certificate(ssl, the_cert);
+	SSL_use_PrivateKey(ssl, the_key);
+
+	bev = bufferevent_openssl_socket_new(
+		base, fd, ssl, BUFFEREVENT_SSL_ACCEPTING, ctx->flags);
+
+	TT_BLATHER(("wm_transfer-%s(%p): accept",
+		ctx->server ? "server" : "client", bev));
+
+	bufferevent_setwatermark(bev, EV_READ, 0, ctx->wm_high);
+	bufferevent_setcb(bev, wm_transfer, NULL, wm_eventcb, ctx);
+	bufferevent_enable(bev, EV_READ|EV_WRITE);
+	ctx->bev = bev;
+
+	/* Only accept once, then disable ourself. */
+	evconnlistener_disable(listener);
+}
+static void
+regress_bufferevent_openssl_wm(void *arg)
+{
+	struct basic_test_data *data = arg;
+	struct event_base *base = data->base;
+
+	struct evconnlistener *listener;
+	struct bufferevent *bev;
+	struct sockaddr_in sin;
+	struct sockaddr_storage ss;
+	enum regress_openssl_type type =
+		(enum regress_openssl_type)data->setup_data;
+	int bev_flags = BEV_OPT_CLOSE_ON_FREE;
+	ev_socklen_t slen;
+	SSL *ssl;
+	struct wm_context client, server;
+	char *payload;
+	size_t payload_len = 1<<10;
+	size_t wm_high = 5<<10;
+
+	memset(&sin, 0, sizeof(sin));
+	sin.sin_family = AF_INET;
+	sin.sin_addr.s_addr = htonl(0x7f000001);
+
+	memset(&ss, 0, sizeof(ss));
+	slen = sizeof(ss);
+
+	if (type & REGRESS_DEFERRED_CALLBACKS)
+		bev_flags |= BEV_OPT_DEFER_CALLBACKS;
+
+	memset(&client, 0, sizeof(client));
+	memset(&server, 0, sizeof(server));
+	client.server = 0;
+	server.server = 1;
+	client.flags = server.flags = bev_flags;
+	client.data = evbuffer_new();
+	server.data = evbuffer_new();
+	payload = calloc(1, payload_len);
+	memset(payload, 'A', payload_len);
+	evbuffer_add(server.data, payload, payload_len);
+	evbuffer_add(client.data, payload, payload_len);
+	client.wm_high = server.wm_high = wm_high;
+	client.limit = server.limit = wm_high<<3;
+	client.to_read = server.to_read = payload_len>>1;
+
+	TT_BLATHER(("openssl_wm: "
+		"payload_len = " EV_SIZE_FMT ", "
+		"wm_high = " EV_SIZE_FMT ", "
+		"limit = " EV_SIZE_FMT ", "
+		"to_read: " EV_SIZE_FMT "",
+		payload_len,
+		wm_high,
+		server.limit,
+		server.to_read));
+
+	listener = evconnlistener_new_bind(base, wm_acceptcb, &server,
+	    LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
+	    -1, (struct sockaddr *)&sin, sizeof(sin));
+
+	tt_assert(listener);
+	tt_assert(evconnlistener_get_fd(listener) >= 0);
+
+	ssl = SSL_new(get_ssl_ctx());
+	tt_assert(ssl);
+
+	if (type & REGRESS_OPENSSL_FILTER) {
+		bev = bufferevent_socket_new(data->base, -1, client.flags);
+		tt_assert(bev);
+		bev = bufferevent_openssl_filter_new(
+			base, bev, ssl, BUFFEREVENT_SSL_CONNECTING, client.flags);
+	} else {
+		bev = bufferevent_openssl_socket_new(
+			data->base, -1, ssl,
+			BUFFEREVENT_SSL_CONNECTING,
+			client.flags);
+	}
+	tt_assert(bev);
+	client.bev = bev;
+
+	server.neighbour = &client;
+	client.neighbour = &server;
+
+	bufferevent_setwatermark(bev, EV_READ, 0, client.wm_high);
+	bufferevent_setcb(bev, wm_transfer, NULL, wm_eventcb, &client);
+
+	tt_assert(getsockname(evconnlistener_get_fd(listener),
+		(struct sockaddr*)&ss, &slen) == 0);
+
+	tt_assert(!bufferevent_socket_connect(bev, (struct sockaddr*)&ss, slen));
+	tt_assert(!evbuffer_add_buffer_reference(bufferevent_get_output(bev), client.data));
+	tt_assert(!bufferevent_enable(bev, EV_READ|EV_WRITE));
+
+	event_base_dispatch(base);
+
+	tt_int_op(client.get, ==, client.limit);
+	tt_int_op(server.get, ==, server.limit);
+end:
+	free(payload);
+	evbuffer_free(client.data);
+	evbuffer_free(server.data);
+	evconnlistener_free(listener);
+	bufferevent_free(client.bev);
+	bufferevent_free(server.bev);
 }
 
 struct testcase_t ssl_testcases[] = {
 #define T(a) ((void *)(a))
 	{ "bufferevent_socketpair", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup, T(REGRESS_OPENSSL_SOCKETPAIR) },
+	  TT_ISOLATED, &ssl_setup, T(REGRESS_OPENSSL_SOCKETPAIR) },
 	{ "bufferevent_socketpair_write_after_connect", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR|REGRESS_OPENSSL_CLIENT_WRITE) },
 	{ "bufferevent_filter", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup, T(REGRESS_OPENSSL_FILTER) },
+	  TT_ISOLATED, &ssl_setup, T(REGRESS_OPENSSL_FILTER) },
 	{ "bufferevent_filter_write_after_connect", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER|REGRESS_OPENSSL_CLIENT_WRITE) },
 	{ "bufferevent_renegotiate_socketpair", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_RENEGOTIATE) },
 	{ "bufferevent_renegotiate_filter", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_RENEGOTIATE) },
 	{ "bufferevent_socketpair_startopen", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_OPEN) },
 	{ "bufferevent_filter_startopen", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_OPEN) },
 
 	{ "bufferevent_socketpair_dirty_shutdown", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 	{ "bufferevent_filter_dirty_shutdown", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 	{ "bufferevent_renegotiate_socketpair_dirty_shutdown",
 	  regress_bufferevent_openssl,
 	  TT_ISOLATED,
-	  &basic_setup,
+	  &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_RENEGOTIATE | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 	{ "bufferevent_renegotiate_filter_dirty_shutdown",
 	  regress_bufferevent_openssl,
 	  TT_ISOLATED,
-	  &basic_setup,
+	  &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_RENEGOTIATE | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 	{ "bufferevent_socketpair_startopen_dirty_shutdown",
 	  regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_OPEN | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 	{ "bufferevent_filter_startopen_dirty_shutdown",
 	  regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_OPEN | REGRESS_OPENSSL_DIRTY_SHUTDOWN) },
 
 	{ "bufferevent_socketpair_fd", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_FD) },
 	{ "bufferevent_socketpair_freed", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_FREED) },
 	{ "bufferevent_socketpair_freed_fd", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_FREED | REGRESS_OPENSSL_FD) },
 	{ "bufferevent_filter_freed_fd", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_FILTER | REGRESS_OPENSSL_FREED | REGRESS_OPENSSL_FD) },
 
 	{ "bufferevent_socketpair_timeout", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_TIMEOUT) },
 	{ "bufferevent_socketpair_timeout_freed_fd", regress_bufferevent_openssl,
-	  TT_ISOLATED, &basic_setup,
+	  TT_ISOLATED, &ssl_setup,
 	  T(REGRESS_OPENSSL_SOCKETPAIR | REGRESS_OPENSSL_TIMEOUT | REGRESS_OPENSSL_FREED | REGRESS_OPENSSL_FD) },
 
 	{ "bufferevent_connect", regress_bufferevent_openssl_connect,
-	  TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, NULL },
 	{ "bufferevent_connect_sleep", regress_bufferevent_openssl_connect,
-	  TT_FORK|TT_NEED_BASE, &basic_setup, T(REGRESS_OPENSSL_SLEEP) },
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, T(REGRESS_OPENSSL_SLEEP) },
+
+	{ "bufferevent_wm", regress_bufferevent_openssl_wm,
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, NULL },
+	{ "bufferevent_wm_filter", regress_bufferevent_openssl_wm,
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, T(REGRESS_OPENSSL_FILTER) },
+	{ "bufferevent_wm_defer", regress_bufferevent_openssl_wm,
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, T(REGRESS_DEFERRED_CALLBACKS) },
+	{ "bufferevent_wm_filter_defer", regress_bufferevent_openssl_wm,
+	  TT_FORK|TT_NEED_BASE, &ssl_setup, T(REGRESS_OPENSSL_FILTER|REGRESS_DEFERRED_CALLBACKS) },
 
 #undef T