More unit tests for Openssl, including initializing with no socket. Up to 75% coverage.

svn:r1399

diff --git a/bufferevent_openssl.c b/bufferevent_openssl.c
index 7983a0670494758f651f50542529b6644c1afb6a..aa38f44f1f947968adcc9762c0c4c3e7a1261265 100644 (file)
--- a/bufferevent_openssl.c
+++ b/bufferevent_openssl.c
@@ -1090,9 +1090,11 @@ bufferevent_openssl_new_impl(struct event_base *base,
                bufferevent_enable(underlying, EV_READ|EV_WRITE);
        else {
                bev_ssl->bev.bev.enabled = EV_READ|EV_WRITE;
-               /* XXX Is this quite right? */
-               event_add(&bev_ssl->bev.bev.ev_read, NULL);
-               event_add(&bev_ssl->bev.bev.ev_write, NULL);
+               if (bev_ssl->fd_is_set) {
+                       /* XXX Is this quite right? */
+                       event_add(&bev_ssl->bev.bev.ev_read, NULL);
+                       event_add(&bev_ssl->bev.bev.ev_write, NULL);
+               }
        }
 
        return &bev_ssl->bev.bev;

diff --git a/test/regress_ssl.c b/test/regress_ssl.c
index 140e1e9ec64f12d1df12844d2d72fe10b2603962..fd30e3c0329d2147259b57b66995e94b6a044d58 100644 (file)
--- a/test/regress_ssl.c
+++ b/test/regress_ssl.c
@@ -29,10 +29,16 @@
 #include <windows.h>
 #endif
 
+#ifndef WIN32
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif
+
 #include <event2/util.h>
 #include <event2/event.h>
 #include <event2/bufferevent_ssl.h>
 #include <event2/buffer.h>
+#include <event2/listener.h>
 
 #include "regress.h"
 #include "tinytest.h"
@@ -121,10 +127,11 @@ end:
        return NULL;
 }
 
+static SSL_CTX *the_ssl_ctx = NULL;
+
 static SSL_CTX *
 get_ssl_ctx(void)
 {
-       static SSL_CTX *the_ssl_ctx = NULL;
        if (the_ssl_ctx)
                return the_ssl_ctx;
        return (the_ssl_ctx = SSL_CTX_new(SSLv23_method()));
@@ -241,6 +248,8 @@ regress_bufferevent_openssl(void *arg)
                        ssl2,
                        BUFFEREVENT_SSL_ACCEPTING,
                        BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
+
+               tt_int_op(bufferevent_getfd(bev1), ==, data->pair[0]);
        } else if (strstr((char*)data->setup_data, "filter")) {
                struct bufferevent *bev_ll1, *bev_ll2;
                bev_ll1 = bufferevent_socket_new(data->base, data->pair[0],
@@ -261,6 +270,7 @@ regress_bufferevent_openssl(void *arg)
                        ssl2,
                        BUFFEREVENT_SSL_ACCEPTING,
                        BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
+               tt_ptr_op(bufferevent_get_underlying(bev1), ==, bev_ll1);
        } else {
                TT_DIE(("Bad setup data %s", (char*)data->setup_data));
        }
@@ -288,6 +298,89 @@ end:
        return;
 }
 
+static void
+acceptcb(struct evconnlistener *listener, evutil_socket_t fd,
+    struct sockaddr *addr, int socklen, void *arg)
+{
+       struct basic_test_data *data = arg;
+       struct bufferevent *bev;
+       SSL *ssl = SSL_new(get_ssl_ctx());
+
+       SSL_use_certificate(ssl, getcert());
+       SSL_use_PrivateKey(ssl, getkey());
+
+       bev = bufferevent_openssl_socket_new(
+               data->base,
+               fd,
+               ssl,
+               BUFFEREVENT_SSL_ACCEPTING,
+               BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
+
+       bufferevent_setcb(bev, respond_to_number, NULL, eventcb,
+           (void*)"server");
+
+       bufferevent_enable(bev, EV_READ|EV_WRITE);
+
+       /* Only accept once, then disable ourself. */
+       evconnlistener_disable(listener);
+}
+
+static void
+regress_bufferevent_openssl_connect(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;
+       ev_socklen_t slen;
+
+       init_ssl();
+
+       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);
+
+       listener = evconnlistener_new_bind(base, acceptcb, data,
+           LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE,
+           -1, (struct sockaddr *)&sin, sizeof(sin));
+
+       tt_assert(listener);
+       tt_assert(evconnlistener_get_fd(listener) >= 0);
+
+       bev = bufferevent_openssl_socket_new(
+               data->base, -1, SSL_new(get_ssl_ctx()),
+               BUFFEREVENT_SSL_CONNECTING,
+               BEV_OPT_CLOSE_ON_FREE|BEV_OPT_DEFER_CALLBACKS);
+       tt_assert(bev);
+
+       bufferevent_setcb(bev, respond_to_number, NULL, eventcb,
+           (void*)"client");
+
+       tt_assert(getsockname(evconnlistener_get_fd(listener),
+               (struct sockaddr*)&ss, &slen) == 0);
+       tt_assert(slen == sizeof(struct sockaddr_in));
+       tt_int_op(((struct sockaddr*)&ss)->sa_family, ==, AF_INET);
+       tt_int_op(((struct sockaddr*)&ss)->sa_family, ==, AF_INET);
+
+       tt_assert(0 ==
+           bufferevent_socket_connect(bev, (struct sockaddr*)&ss, slen));
+       evbuffer_add_printf(bufferevent_get_output(bev), "1\n");
+       bufferevent_enable(bev, EV_READ|EV_WRITE);
+
+       puts("Dispatch");
+
+       event_base_dispatch(base);
+end:
+       ;
+}
+
 struct testcase_t ssl_testcases[] = {
 
        { "bufferevent_socketpair", regress_bufferevent_openssl, TT_ISOLATED,
@@ -298,9 +391,12 @@ struct testcase_t ssl_testcases[] = {
        { "bufferevent_renegotiate_socketpair", regress_bufferevent_openssl,
          TT_ISOLATED,
          &basic_setup, (void*)"socketpair renegotiate" },
-       { "bufferevent_renegotiate_filterfilter", regress_bufferevent_openssl,
+       { "bufferevent_renegotiate_filter", regress_bufferevent_openssl,
          TT_ISOLATED,
          &basic_setup, (void*)"filter renegotiate" },
 
+       { "bufferevent_connect", regress_bufferevent_openssl_connect,
+         TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
+
         END_OF_TESTCASES,
 };