Merge lp:~ppergame/pyopenssl/next-proto into lp:~exarkun/pyopenssl/trunk

[Pavel Pergamenshchik]

Next Protocol Negotiation support. I tried not to leak any memory at the OpenSSL API boundaries

[Jean-Paul Calderone (exarkun)]

I just noticed that https://code.launchpad.net/~myers-1/pyopenssl/npn/+merge/92416 also exists. Which one of these should I choose to move forward on?

[Jean-Paul Calderone (exarkun)]

Looks like this one is more likely to see further activity, so I'll proceed here.

  1. There are some new XXXs in the code (copied from templates, I guess). It'd be nice if they were actually addressed instead. Since it's impractical to exercise malloc failures here, don't worry about unit testing. Just think really hard.
  2. Reference counting in ssl_Context_set_next_protos_advertised_cb is incorrect. I think it is possible for `self->next_protos_advertised_callback` to be the only thing keeping `self` alive, or perhaps for a weak reference callback or `__del__` on `self->next_protos_advertised_callback` to re-enter some part of ssl_Context_*. Since `self->next_protos_advertised_callback` is DECREFed while it is still in the `self` structure, this will probably lead to brokenness. I think this is what the Py_CLEAR macro (not heavily used throughout pyOpenSSL) is for. Same applies for next_protos_advertised_userdata, next_proto_select_callback, and next_proto_select_userdata. Maybe the (existing and new) code in `ssl_Context_clear` is fine though? I'm not clear on the re-entrancy issues of tp_clear, and I don't feel like digging them up.
  3. Some Python 3 issues in the Python code - except syntax (test_ssl.py, line 1125) and byte string literal syntax (b("foo") instead of "foo" to construct a byte string). I'm already set up to develop/test against Python 3.3 so I can take care of this if it's too much hassle for you, after the above points are addressed.

Thanks.

review: Needs Fixing

Unmerged revisions

178. By Pavel Pergamenshchik on 2012-05-18

rename get0 -> get, add proper test skipping

177. By Pavel Pergamenshchik on 2012-05-18

skip test if no NPN support in openssl

176. By Pavel Pergamenshchik on 2012-05-18

move the endif to the correct spot

175. By Pavel Pergamenshchik on 2012-05-18

pass the Connection to python next proto callbacks, use Connection threadstate

174. By Pavel Pergamenshchik on 2012-05-17

conditional compilation, more exceptions, more tests

173. By Pavel Pergamenshchik on 2012-05-15

test select returning none

172. By Pavel Pergamenshchik on 2012-05-15

get0_next_proto_negotiated tests

171. By Pavel Pergamenshchik on 2012-05-15

get0_next_proto_negotiated

170. By Pavel Pergamenshchik on 2012-05-10

npn advertisement compiles

169. By Pavel Pergamenshchik <ppergame@ppergame-glaptop> on 2012-05-10

untested next_proto_advertised_cb

=== modified file 'OpenSSL/ssl/connection.c'
--- OpenSSL/ssl/connection.c	2012-03-11 01:18:02 +0000
+++ OpenSSL/ssl/connection.c	2012-05-18 00:57:18 +0000
@@ -1396,6 +1396,30 @@
     return Py_None;
 }
 
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+static char ssl_Connection_get_next_proto_negotiated_doc[] = "\n\
+Returns the next proto selected by the client\n\
+\n\
+:return: Non-empty next proto string, or None if there isn't one\n\
+";
+static PyObject *
+ssl_Connection_get_next_proto_negotiated(ssl_ConnectionObj *self, PyObject *args)
+{
+    const char *data;
+    unsigned len;
+    if (!PyArg_ParseTuple(args, ":set_next_proto_select_cb"))
+        return NULL;
+
+    SSL_get0_next_proto_negotiated(self->ssl, (const unsigned char **)&data, &len);
+    if (!data) {
+        Py_INCREF(Py_None);
+        return Py_None;
+    } else {
+        return PyBytes_FromStringAndSize(data, len);
+    }
+}
+#endif
+
 /*
  * Member methods in the Connection object
  * ADD_METHOD(name) expands to a correct PyMethodDef declaration
@@ -1453,6 +1477,9 @@
     ADD_METHOD(set_connect_state),
     ADD_METHOD(get_session),
     ADD_METHOD(set_session),
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+    ADD_METHOD(get_next_proto_negotiated),
+#endif
     { NULL, NULL }
 };
 #undef ADD_ALIAS
@@ -1518,6 +1545,10 @@
             SSL_set_fd(self->ssl, (SOCKET_T)fd);
         }
     }
+
+    self->last_next_protos_advertised_str = NULL;
+    self->last_next_proto_select_str = NULL;
+
     return self;
 
 error:
@@ -1632,6 +1663,12 @@
     self->app_data = NULL;
     self->into_ssl = NULL; /* was cleaned up by SSL_free() */
     self->from_ssl = NULL; /* was cleaned up by SSL_free() */
+
+    PyMem_Free(self->last_next_protos_advertised_str);
+    self->last_next_protos_advertised_str = NULL;
+    PyMem_Free(self->last_next_proto_select_str);
+    self->last_next_proto_select_str = NULL;
+
     return 0;
 }
 

=== modified file 'OpenSSL/ssl/connection.h'
--- OpenSSL/ssl/connection.h	2011-03-03 00:26:20 +0000
+++ OpenSSL/ssl/connection.h	2012-05-18 00:57:18 +0000
@@ -45,6 +45,8 @@
     PyThreadState       *tstate; /* This field is no longer used. */
     PyObject            *app_data;
     BIO                 *into_ssl, *from_ssl;  /* for connections without file descriptors */
+    unsigned char       *last_next_protos_advertised_str;
+    unsigned char       *last_next_proto_select_str;
 } ssl_ConnectionObj;
 
 

=== modified file 'OpenSSL/ssl/context.c'
--- OpenSSL/ssl/context.c	2012-03-09 23:04:04 +0000
+++ OpenSSL/ssl/context.c	2012-05-18 00:57:18 +0000
@@ -148,6 +148,276 @@
     return len;
 }
 
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+/*
+ * Globally defined next protocol advertisement callback.  This is called from
+ * OpenSSL internally. Return the encoded next proto list.
+ *
+ * Arguments: ssl    - OpenSSL context
+ *            out    - Pointer to the pointer to be set to the output string of
+ *                     of the form '\003foo\004barf'
+ *            outlen - Pointer to the value to be set to length of output
+ *                     string
+ *            arg    - User data, always a Context object
+ * Returns:   SSL_TLSEXT_ERR_OK or SSL_TLSEXT_ERR_ALERT_FATAL
+ */
+static int
+global_next_protos_advertised_callback(SSL *ssl, const unsigned char **out,
+        unsigned int *outlen, void *arg)
+{
+    int ssl_ret = SSL_TLSEXT_ERR_ALERT_FATAL;
+    char *out_str = NULL, *cur_pos, *raw_str;
+    Py_ssize_t str_size, final_size = 0, num_protos, ctr;
+    PyObject *argv, *protos = NULL, *proto;
+    ssl_ConnectionObj *conn = (ssl_ConnectionObj *)SSL_get_app_data(ssl);
+    ssl_ContextObj *ctx = conn->context;
+
+    /*
+     * GIL isn't held yet.  First things first - acquire it, or any Python API
+     * we invoke might segfault or blow up the sun.  The reverse will be done
+     * before returning.
+     */
+    MY_END_ALLOW_THREADS(conn->tstate);
+
+    /*
+     * Allocation model: OpenSSL promises to "keep a reference" to the output
+     * string. Actually, OpenSSL makes a copy shortly after this callback
+     * returns, so we have to keep a pointer to the string and deallocate
+     * it later. There is a race condition between OpenSSL using the output
+     * string and calling this callback again. Don't like it? Blame the
+     * Chromium contributor who put this idiocy into OpenSSL.
+     */
+    PyMem_Free(conn->last_next_protos_advertised_str);
+    conn->last_next_protos_advertised_str = NULL;
+
+    /* The Python callback is called with a (conn, userdata) tuple */
+    argv = Py_BuildValue("(OO)", conn, ctx->next_protos_advertised_userdata);
+
+    /*
+     * XXX Didn't check argv to see if it was NULL. -exarkun
+     */
+    protos = PyEval_CallObject(ctx->next_protos_advertised_callback, argv);
+    Py_DECREF(argv);
+
+    if (protos == NULL) {
+        /*
+         * The callback raised an exception.  It will be raised by whatever
+         * Python API triggered this callback.
+         */
+        goto out;
+    }
+
+    if (protos == Py_None) {
+        /*
+         * Don't advertise next proto at all
+         */
+        goto out;
+    }
+
+    if (!PySequence_Check(protos) || PyBytes_Check(protos)) {
+        /*
+         * Got non-sequence or a string
+         */
+        PyErr_SetString(PyExc_TypeError, "next_protos_advertised_callback"
+                "returned a value that is not a list of strings");
+        goto out;
+    }
+
+    num_protos = PySequence_Size(protos);
+    if (num_protos == -1)
+    {
+        goto out;
+    }
+
+    // first pass to find out how much memory to allocate
+    for (ctr = 0; ctr < num_protos; ctr++) {
+        proto = PySequence_GetItem(protos, ctr);
+        if (!proto) {
+            goto out;
+        }
+        if (!PyBytes_Check(proto)) {
+            Py_DECREF(proto);
+            PyErr_Format(PyExc_TypeError, "next_protos_advertised_callback"
+                    "return sequence contains a non-string");
+            goto out;
+        }
+        str_size = PyBytes_Size(proto);
+        if (str_size == -1) {
+            Py_DECREF(proto);
+            goto out;
+        } else if (str_size < 1 || str_size > 255) {
+            Py_DECREF(proto);
+            PyErr_Format(PyExc_TypeError, "next_protos_advertised_callback"
+                    "return sequence contains an empty string or a string"
+                    "larger than 255 bytes");
+            goto out;
+        }
+        final_size = final_size + 1 + str_size;
+        Py_DECREF(proto);
+    }
+
+    cur_pos = out_str = PyMem_Malloc(final_size);
+
+    for (ctr = 0; ctr < num_protos; ctr++) {
+        proto = PySequence_GetItem(protos, ctr);
+        if (PyBytes_AsStringAndSize(proto, &raw_str, &str_size) == -1) {
+            PyMem_Free(out_str);
+            goto out;
+        }
+
+        *cur_pos = str_size;
+        memcpy(cur_pos + 1, raw_str, str_size);
+        cur_pos = cur_pos + 1 + str_size;
+        Py_DECREF(proto);
+    }
+
+    *out = conn->last_next_protos_advertised_str = (unsigned char *)out_str;
+    *outlen = final_size;
+    ssl_ret = SSL_TLSEXT_ERR_OK;
+
+out:
+    Py_XDECREF(protos);
+    /*
+     * This function is returning into OpenSSL.  Release the GIL again.
+     */
+    MY_BEGIN_ALLOW_THREADS(conn->tstate);
+    return ssl_ret;
+}
+
+/*
+ * Globally defined next protocol selection callback.  This is called from
+ * OpenSSL internally. Return the selected next proto string.
+ *
+ * Arguments: ssl    - OpenSSL context
+ *            out    - Pointer to the pointer to be set to the next protocol
+ *                     string
+ *            outlen - Pointer to the value to be set to length of output
+ *                     string
+ *            in     - Encoded string of next protos advertised by the server
+ *            inlen  - Length of in
+ *            arg    - User data, always a Context object
+ * Returns:   SSL_TLSEXT_ERR_OK or SSL_TLSEXT_ERR_ALERT_FATAL
+ */
+static int
+global_next_proto_select_callback(SSL *ssl, unsigned char **out,
+        unsigned char *outlen, const unsigned char *in, unsigned int inlen,
+        void *arg)
+{
+    int ssl_ret = SSL_TLSEXT_ERR_ALERT_FATAL, ret;
+    char *out_str, *raw_str;
+    const unsigned char *cur_pos;
+    unsigned char proto_size;
+    PyObject *argv, *proto = NULL, *proto_list, *proto_bytes;
+    Py_ssize_t str_size;
+    ssl_ConnectionObj *conn = (ssl_ConnectionObj *)SSL_get_app_data(ssl);
+    ssl_ContextObj *ctx = conn->context;
+
+    /*
+     * GIL isn't held yet.  First things first - acquire it, or any Python API
+     * we invoke might segfault or blow up the sun.  The reverse will be done
+     * before returning.
+     */
+    MY_END_ALLOW_THREADS(ctx->tstate);
+
+    /*
+     * Allocation model: OpenSSL promises to "keep a reference" to the output
+     * string. Actually, OpenSSL makes a copy shortly after this callback
+     * returns, so we have to keep a pointer to the string and deallocate
+     * it later. There is a race condition between OpenSSL using the output
+     * string and calling this callback again. Don't like it? Blame the
+     * Chromium contributor who put this idiocy into OpenSSL.
+     */
+    PyMem_Free(conn->last_next_proto_select_str);
+    conn->last_next_proto_select_str = NULL;
+
+    proto_list = PyList_New(0);
+    if (!proto_list) {
+        goto out;
+    }
+    cur_pos = in;
+    while (in + inlen > cur_pos) {
+        proto_size = *cur_pos++;
+        if (in + inlen < cur_pos + proto_size) {
+            Py_DECREF(proto_list);
+            PyErr_Format(PyExc_RuntimeError, "next_proto_select_callback"
+                    "received improperly encoded proto list from OpenSSL");
+            goto out;
+        }
+        proto_bytes = PyBytes_FromStringAndSize((char *)cur_pos, proto_size);
+        if (!proto_bytes) {
+            Py_DECREF(proto_list);
+            goto out;
+        }
+        ret = PyList_Append(proto_list, proto_bytes);
+        Py_DECREF(proto_bytes);
+        if (ret) {
+            Py_DECREF(proto_list);
+            goto out;
+        }
+        cur_pos += proto_size;
+    }
+
+    /* The Python callback is called with a (proto_list, conn, userdata) tuple */
+    argv = Py_BuildValue("(OOO)", proto_list, conn,
+            ctx->next_proto_select_userdata);
+    Py_DECREF(proto_list);
+
+    /*
+     * XXX Didn't check argv to see if it was NULL. -exarkun
+     */
+    proto = PyEval_CallObject(ctx->next_proto_select_callback, argv);
+    Py_DECREF(argv);
+
+    if (proto == NULL) {
+        /*
+         * The callback raised an exception.  It will be raised by whatever
+         * Python API triggered this callback.
+         */
+        goto out;
+    }
+
+    if (proto == Py_None) {
+        /*
+         * No proto to select results in connection loss
+         */
+        goto out;
+    }
+
+    if (!PyBytes_Check(proto)) {
+        /*
+         * Not a string
+         */
+        PyErr_Format(PyExc_TypeError, "next_proto_select_callback"
+                "returned neither string nor None");
+        goto out;
+    }
+
+    if (PyBytes_AsStringAndSize(proto, &raw_str, &str_size) == -1) {
+        goto out;
+    }
+    if (str_size < 1 || str_size > 255) {
+        PyErr_Format(PyExc_TypeError, "next_proto_select_callback"
+                "returned empty string or string larger than 255 bytes");
+        goto out;
+    }
+
+    out_str = PyMem_Malloc(str_size);
+    memcpy(out_str, raw_str, str_size);
+
+    *out = conn->last_next_proto_select_str = (unsigned char *)out_str;
+    *outlen = str_size;
+    ssl_ret = SSL_TLSEXT_ERR_OK;
+
+out:
+    Py_XDECREF(proto);
+    /*
+     * This function is returning into OpenSSL.  Release the GIL again.
+     */
+    MY_BEGIN_ALLOW_THREADS(conn->tstate);
+    return ssl_ret;
+}
+#endif
+
 /*
  * Globally defined verify callback
  *
@@ -387,6 +657,88 @@
     return Py_None;
 }
 
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+static char ssl_Context_set_next_protos_advertised_cb_doc[] = "\n\
+Set the callback that returns next protos advertised by this server\n\
+\n\
+:param callback: The Python callback to use. Takes a Connection and userdata.\n\
+                 Returns a sequence of strings, or None to suppress next proto\n\
+                 support\n\
+:param userdata: (optional) A Python object which will be given as\n\
+                 argument to the callback\n\
+:return: None\n\
+";
+static PyObject *
+ssl_Context_set_next_protos_advertised_cb(ssl_ContextObj *self, PyObject *args)
+{
+    PyObject *callback = NULL, *userdata = Py_None;
+
+    if (!PyArg_ParseTuple(args, "O|O:set_next_protos_advertised_cb", &callback,
+                &userdata))
+        return NULL;
+
+    if (!PyCallable_Check(callback))
+    {
+        PyErr_SetString(PyExc_TypeError, "expected PyCallable");
+        return NULL;
+    }
+
+    Py_DECREF(self->next_protos_advertised_callback);
+    Py_INCREF(callback);
+    self->next_protos_advertised_callback = callback;
+
+    Py_DECREF(self->next_protos_advertised_userdata);
+    Py_INCREF(userdata);
+    self->next_protos_advertised_userdata = userdata;
+    
+    SSL_CTX_set_next_protos_advertised_cb(self->ctx,
+            global_next_protos_advertised_callback, NULL);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+static char ssl_Context_set_next_proto_select_cb_doc[] = "\n\
+Set the callback that returns next proto selected by this client\n\
+\n\
+:param callback: The Python callback to use. Takes a list of next proto\n\
+                 strings, a Connection and userdata. Returns the next proto\n\
+                 string, or None to terminate the connection\n\
+:param userdata: (optional) A Python object which will be given as\n\
+                 argument to the callback\n\
+:return: None\n\
+";
+static PyObject *
+ssl_Context_set_next_proto_select_cb(ssl_ContextObj *self, PyObject *args)
+{
+    PyObject *callback = NULL, *userdata = Py_None;
+
+    if (!PyArg_ParseTuple(args, "O|O:set_next_proto_select_cb", &callback,
+                &userdata))
+        return NULL;
+
+    if (!PyCallable_Check(callback))
+    {
+        PyErr_SetString(PyExc_TypeError, "expected PyCallable");
+        return NULL;
+    }
+
+    Py_DECREF(self->next_proto_select_callback);
+    Py_INCREF(callback);
+    self->next_proto_select_callback = callback;
+
+    Py_DECREF(self->next_proto_select_userdata);
+    Py_INCREF(userdata);
+    self->next_proto_select_userdata = userdata;
+    
+    SSL_CTX_set_next_proto_select_cb(self->ctx,
+            global_next_proto_select_callback, NULL);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+#endif
+
 static PyTypeObject *
 type_modified_error(const char *name) {
     PyErr_Format(PyExc_RuntimeError,
@@ -1199,6 +1551,10 @@
 static PyMethodDef ssl_Context_methods[] = {
     ADD_METHOD(load_verify_locations),
     ADD_METHOD(set_passwd_cb),
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
+    ADD_METHOD(set_next_protos_advertised_cb),
+    ADD_METHOD(set_next_proto_select_cb),
+#endif
     ADD_METHOD(set_default_verify_paths),
     ADD_METHOD(use_certificate_chain_file),
     ADD_METHOD(use_certificate_file),
@@ -1276,6 +1632,10 @@
     Py_INCREF(Py_None);
     self->passphrase_callback = Py_None;
     Py_INCREF(Py_None);
+    self->next_protos_advertised_callback = Py_None;
+    Py_INCREF(Py_None);
+    self->next_proto_select_callback = Py_None;
+    Py_INCREF(Py_None);
     self->verify_callback = Py_None;
     Py_INCREF(Py_None);
     self->info_callback = Py_None;
@@ -1287,6 +1647,12 @@
     self->passphrase_userdata = Py_None;
 
     Py_INCREF(Py_None);
+    self->next_protos_advertised_userdata = Py_None;
+
+    Py_INCREF(Py_None);
+    self->next_proto_select_userdata = Py_None;
+
+    Py_INCREF(Py_None);
     self->app_data = Py_None;
 
     /* Some initialization that's required to operate smoothly in Python */
@@ -1378,6 +1744,14 @@
     self->passphrase_callback = NULL;
     Py_XDECREF(self->passphrase_userdata);
     self->passphrase_userdata = NULL;
+    Py_XDECREF(self->next_protos_advertised_callback);
+    self->next_protos_advertised_callback = NULL;
+    Py_XDECREF(self->next_protos_advertised_userdata);
+    self->next_protos_advertised_userdata = NULL;
+    Py_XDECREF(self->next_proto_select_callback);
+    self->next_proto_select_callback = NULL;
+    Py_XDECREF(self->next_proto_select_userdata);
+    self->next_proto_select_userdata = NULL;
     Py_XDECREF(self->verify_callback);
     self->verify_callback = NULL;
     Py_XDECREF(self->info_callback);

=== modified file 'OpenSSL/ssl/context.h'
--- OpenSSL/ssl/context.h	2011-05-26 22:47:00 +0000
+++ OpenSSL/ssl/context.h	2012-05-18 00:57:18 +0000
@@ -27,6 +27,10 @@
     SSL_CTX             *ctx;
     PyObject            *passphrase_callback,
                         *passphrase_userdata,
+                        *next_protos_advertised_callback,
+                        *next_protos_advertised_userdata,
+                        *next_proto_select_callback,
+                        *next_proto_select_userdata,
                         *verify_callback,
                         *info_callback,
                         *tlsext_servername_callback,

=== modified file 'OpenSSL/test/test_ssl.py'
--- OpenSSL/test/test_ssl.py	2012-03-09 23:27:50 +0000
+++ OpenSSL/test/test_ssl.py	2012-05-18 00:57:18 +0000
@@ -961,6 +961,230 @@
 
 
 
+class NextProtocolNegotiationTests(TestCase, _LoopbackMixin):
+    """
+    Tests for :py:obj:`Context.set_next_protos_advertised_callback`,
+    :py:obj:`Context.set_next_proto_select_callback` and
+    :py:obj:`Connection.get_next_proto_negotiated`
+    """
+    if not hasattr(Connection, 'get_next_proto_negotiated'):
+        'Next proto negotiation is not supported by this OpenSSL version'
+    else:
+        def tearDown(self):
+            self.serverContext = self.clientContext = self.server = self.client = None
+
+        def initNextProto(self, advertise = None, select = None):
+            """
+            Set up a client and a server :py:obj:`Connection`, and set their
+            next proto negotiation callbacks
+            """
+
+            serverContext = Context(TLSv1_METHOD)
+            if advertise:
+                serverContext.set_next_protos_advertised_cb(advertise)
+            serverContext.use_privatekey(load_privatekey(FILETYPE_PEM, server_key_pem))
+            serverContext.use_certificate(load_certificate(FILETYPE_PEM, server_cert_pem))
+
+            server = Connection(serverContext, None)
+            server.set_accept_state()
+
+            clientContext = Context(TLSv1_METHOD)
+            if select:
+                clientContext.set_next_proto_select_cb(select)
+            client = Connection(clientContext, None)
+            client.set_connect_state()
+
+            self.serverContext = serverContext
+            self.clientContext = clientContext
+            self.server = server
+            self.client = client
+
+
+        def test_select_no_advertise(self):
+            """
+            Next proto select callback isn't called if the server
+            does not advertise
+            """
+
+            select_calls = []
+            def select(protos, conn, extra):
+                select_calls.append((protos, conn, extra))
+
+            self.initNextProto(select = select)
+
+            self._interactInMemory(self.client, self.server)
+
+            self.assertEquals(select_calls, [])
+
+            self.assertEquals(self.client.get_next_proto_negotiated(), None)
+            self.assertEquals(self.server.get_next_proto_negotiated(), None)
+
+
+        def test_select_raises(self):
+            """
+            Exceptions in next proto select callback are propagated to the caller
+            """
+
+            def advertise(conn, extra):
+                return ['spdy/2.0', 'http/1.1']
+            def select(protos, conn, extra):
+                1/0
+
+            self.initNextProto(advertise = advertise, select = select)
+            self.assertRaises(ZeroDivisionError,
+                    self._interactInMemory, self.client, self.server)
+
+
+        def test_select_bad(self):
+            """
+            TypeError is raised if select callback returns a bogus value
+            """
+
+            bad_returns = [5, '', 'x' * 256]
+
+            def advertise(conn, extra):
+                return ['spdy/2.0', 'http/1.1']
+
+            for bad in bad_returns:
+                self.initNextProto(advertise = advertise, select = lambda protos, extra: bad)
+                self.assertRaises(TypeError,
+                        self._interactInMemory, self.client, self.server)
+
+
+        def test_advertise_raises(self):
+            """
+            Exceptions in next proto advertisement callback are propagated
+            to the caller
+            """
+
+            def advertise(conn, extra):
+                1/0
+            def select(protos, conn, extra):
+                return 'gopher'
+
+            self.initNextProto(advertise = advertise, select = select)
+            self.assertRaises(ZeroDivisionError,
+                    self._interactInMemory, self.client, self.server)
+
+
+        def test_advertise_bad(self):
+            """
+            TypeError is raised if select callback returns a bogus value
+            """
+
+            bad_returns = ['nntp', ['imap4', 6], [''], ['x' * 256]]
+            def select(protos, conn, extra):
+                return 'gopher'
+
+            for bad in bad_returns:
+                self.initNextProto(advertise = lambda extra: bad, select = select)
+                self.assertRaises(TypeError,
+                        self._interactInMemory, self.client, self.server)
+
+
+        def test_advertise_no_select(self):
+            """
+            Next proto advertisement callback isn't called if the client
+            doesn't request next proto support
+            """
+
+            advertise_calls = []
+            def advertise(conn, extra):
+                advertise_calls.append((conn, extra))
+                return ['spdy/2.0', 'http/1.1']
+
+            self.initNextProto(advertise = advertise)
+
+            self._interactInMemory(self.client, self.server)
+
+            self.assertEquals(advertise_calls, [])
+
+            self.assertEquals(self.client.get_next_proto_negotiated(), None)
+            self.assertEquals(self.server.get_next_proto_negotiated(), None)
+
+
+        def test_select_none(self):
+            """
+            Connection is terminated if the client does not choose a next proto
+            """
+            advertise_calls = []
+            def advertise(conn, extra):
+                advertise_calls.append((conn, extra))
+                return ['spdy/2.0', 'http/1.1']
+
+            select_calls = []
+            def select(protos, conn, extra):
+                select_calls.append((protos, conn, extra))
+                # OpenSSL treats this as a fatal condition
+                return None
+
+            self.initNextProto(advertise = advertise, select = select)
+
+            try:
+                self._interactInMemory(self.client, self.server)
+            except Error, e:
+                self.assertEquals(e.args, ([('SSL routines', 'SSL3_GET_SERVER_HELLO', 'parse tlsext')],))
+
+            self.assertEquals(advertise_calls, [(self.server, None)])
+            self.assertEquals(select_calls, [(['spdy/2.0', 'http/1.1'], self.client, None)])
+
+            self.assertEquals(self.client.get_next_proto_negotiated(), None)
+            self.assertEquals(self.server.get_next_proto_negotiated(), None)
+
+
+        def test_advertise_select(self):
+            """
+            Client and server negotiate next proto
+            """
+
+            advertise_calls = []
+            def advertise(conn, extra):
+                advertise_calls.append((conn, extra))
+                return ['spdy/2.0', 'http/1.1']
+
+            select_calls = []
+            def select(protos, conn, extra):
+                select_calls.append((protos, conn, extra))
+                return 'gopher'
+
+            self.initNextProto(advertise = advertise, select = select)
+
+            self._interactInMemory(self.client, self.server)
+
+            self.assertEquals(advertise_calls, [(self.server, None)])
+            self.assertEquals(select_calls, [(['spdy/2.0', 'http/1.1'], self.client, None)])
+
+            self.assertEquals(self.client.get_next_proto_negotiated(), 'gopher')
+            self.assertEquals(self.server.get_next_proto_negotiated(), 'gopher')
+
+
+        def test_advertise_empty(self):
+            """
+            Client receives empty next proto list sent by the server
+            """
+
+            advertise_calls = []
+            def advertise(conn, extra):
+                advertise_calls.append((conn, extra))
+                return []
+
+            select_calls = []
+            def select(protos, conn, extra):
+                select_calls.append((protos, conn, extra))
+                return 'gopher'
+
+            self.initNextProto(advertise = advertise, select = select)
+
+            self._interactInMemory(self.client, self.server)
+
+            self.assertEquals(advertise_calls, [(self.server, None)])
+            self.assertEquals(select_calls, [([], self.client, None)])
+
+            self.assertEquals(self.client.get_next_proto_negotiated(), 'gopher')
+            self.assertEquals(self.server.get_next_proto_negotiated(), 'gopher')
+
+
+
 class ServerNameCallbackTests(TestCase, _LoopbackMixin):
     """
     Tests for :py:obj:`Context.set_tlsext_servername_callback` and its interaction with