diff --git a/modules/ssl/mod_ssl.c b/modules/ssl/mod_ssl.c

index 987b256..c24c6e1 100644

--- a/modules/ssl/mod_ssl.c

+++ b/modules/ssl/mod_ssl.c

@@ -514,6 +514,13 @@ int ssl_engine_disable(conn_rec *c)

     return 1;

 }

+static int modssl_register_npn(conn_rec *c, 

+                               ssl_npn_advertise_protos advertisefn,

+                               ssl_npn_proto_negotiated negotiatedfn)

+{

+    return DECLINED;

+}

+

 int ssl_init_ssl_connection(conn_rec *c, request_rec *r)

 {

     SSLSrvConfigRec *sc;

@@ -706,6 +713,7 @@ static void ssl_register_hooks(apr_pool_t *p)

     APR_REGISTER_OPTIONAL_FN(ssl_proxy_enable);

     APR_REGISTER_OPTIONAL_FN(ssl_engine_disable);

+    APR_REGISTER_OPTIONAL_FN(modssl_register_npn);

     ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ssl",

                               AUTHZ_PROVIDER_VERSION,

diff --git a/modules/ssl/mod_ssl.h b/modules/ssl/mod_ssl.h

index db8ffaf..d381901 100644

--- a/modules/ssl/mod_ssl.h

+++ b/modules/ssl/mod_ssl.h

@@ -84,5 +84,40 @@ APR_DECLARE_OPTIONAL_FN(int, ssl_proxy_enable, (conn_rec *));

 APR_DECLARE_OPTIONAL_FN(int, ssl_engine_disable, (conn_rec *));

+/** The npn_advertise_protos callback allows another modules to add

+ * entries to the list of protocol names advertised by the server

+ * during the Next Protocol Negotiation (NPN) portion of the SSL

+ * handshake.  The callback is given the connection and an APR array;

+ * it should push one or more char*'s pointing to NUL-terminated

+ * strings (such as "http/1.1" or "spdy/2") onto the array and return

+ * OK.  To prevent further processing of (other modules') callbacks,

+ * return DONE. */

+typedef int (*ssl_npn_advertise_protos)(conn_rec *connection, 

+                                        apr_array_header_t *protos);

+

+/** The npn_proto_negotiated callback allows other modules to discover

+ * the name of the protocol that was chosen during the Next Protocol

+ * Negotiation (NPN) portion of the SSL handshake.  Note that this may

+ * be the empty string (in which case modules should probably assume

+ * HTTP), or it may be a protocol that was never even advertised by

+ * the server.  The callback is given the connection, a

+ * non-NUL-terminated string containing the protocol name, and the

+ * length of the string; it should do something appropriate

+ * (i.e. insert or remove filters) and return OK.  To prevent further

+ * processing of (other modules') callbacks, return DONE. */

+typedef int (*ssl_npn_proto_negotiated)(conn_rec *connection, 

+                                        const char *proto_name,

+                                        apr_size_t proto_name_len);

+

+/* An optional function which can be used to register a pair of

+ * callbacks for NPN handling.  This optional function should be

+ * invoked from a pre_connection hook which runs *after* mod_ssl.c's

+ * pre_connection hook.  The function returns OK if the callbacks are

+ * register, or DECLINED otherwise (for example if mod_ssl does not

+l * support NPN).  */

+APR_DECLARE_OPTIONAL_FN(int, modssl_register_npn, (conn_rec *conn, 

+                                                   ssl_npn_advertise_protos advertisefn,

+                                                   ssl_npn_proto_negotiated negotiatedfn));

+

 #endif /* __MOD_SSL_H__ */

 /** @} */

diff --git a/modules/ssl/ssl_engine_init.c b/modules/ssl/ssl_engine_init.c

index 9526f1b..12b2115 100644

--- a/modules/ssl/ssl_engine_init.c

+++ b/modules/ssl/ssl_engine_init.c

@@ -736,6 +736,11 @@ static void ssl_init_ctx_callbacks(server_rec *s,

 #ifdef HAVE_TLS_ALPN

     SSL_CTX_set_alpn_select_cb(ctx, ssl_callback_alpn_select, NULL);

 #endif

+

+#ifdef HAVE_TLS_NPN

+    SSL_CTX_set_next_protos_advertised_cb(

+        ctx, ssl_callback_AdvertiseNextProtos, NULL);

+#endif

 }

 static apr_status_t ssl_init_ctx_verify(server_rec *s,

diff --git a/modules/ssl/ssl_engine_io.c b/modules/ssl/ssl_engine_io.c

index d1f44e9..26ee301 100644

--- a/modules/ssl/ssl_engine_io.c

+++ b/modules/ssl/ssl_engine_io.c

@@ -317,6 +317,7 @@ typedef struct {

     apr_pool_t *pool;

     char buffer[AP_IOBUFSIZE];

     ssl_filter_ctx_t *filter_ctx;

+    int npn_finished;  /* 1 if NPN has finished, 0 otherwise */

 } bio_filter_in_ctx_t;

 /*

@@ -1517,6 +1518,38 @@ static apr_status_t ssl_io_filter_input(ap_filter_t *f,

         return ssl_io_filter_error(inctx, bb, status, is_init);

     }

+#ifdef HAVE_TLS_NPN

+    /* By this point, Next Protocol Negotiation (NPN) should be completed (if

+     * our version of OpenSSL supports it).  If we haven't already, find out

+     * which protocol was decided upon and inform other modules by calling

+     * npn_proto_negotiated_hook. */

+    if (!inctx->npn_finished) {

+        SSLConnRec *sslconn = myConnConfig(f->c);

+        apr_array_header_t *protos = apr_array_make(f->c->pool, 1, sizeof(char *));

+        const unsigned char *next_proto = NULL;

+        unsigned next_proto_len = 0;

+        const unsigned char *out;

+        unsigned char outlen;

+        

+        SSL_get0_next_proto_negotiated(inctx->ssl, &next_proto, &next_proto_len);

+        if (next_proto_len) {

+            ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,

+                          APLOGNO(02306) "SSL NPN negotiated protocol: '%.*s'",

+                          next_proto_len, (const char*)next_proto);

+

+            APR_ARRAY_PUSH(protos, char *) =

+              apr_pstrmemdup(f->c->pool, (const char *)next_proto, next_proto_len);

+            

+            if (modssl_select_protocol(inctx->ssl, f->c, sslconn, protos,

+                                       &out, &outlen) != SSL_TLSEXT_ERR_OK)

+                ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, f->c,

+                              "SSL NPN negotiation failed");

+        }

+            

+        inctx->npn_finished = 1;

+    }

+#endif

+

     if (is_init) {

         /* protocol module needs to handshake before sending

          * data to client (e.g. NNTP or FTP)

@@ -2041,6 +2074,7 @@ static void ssl_io_input_add_filter(ssl_filter_ctx_t *filter_ctx, conn_rec *c,

     inctx->block = APR_BLOCK_READ;

     inctx->pool = c->pool;

     inctx->filter_ctx = filter_ctx;

+    inctx->npn_finished = 0;

 }

 /* The request_rec pointer is passed in here only to ensure that the

diff --git a/modules/ssl/ssl_engine_kernel.c b/modules/ssl/ssl_engine_kernel.c

index 02acd22..dced334 100644

--- a/modules/ssl/ssl_engine_kernel.c

+++ b/modules/ssl/ssl_engine_kernel.c

@@ -2332,6 +2332,142 @@ int ssl_callback_SessionTicket(SSL *ssl,

 }

 #endif /* HAVE_TLS_SESSION_TICKETS */

+#if defined(HAVE_TLS_NPN) || defined(HAVE_TLS_ALPN)

+int modssl_select_protocol(SSL *ssl, conn_rec *c, SSLConnRec *sslconn,

+			   apr_array_header_t *client_protos,

+			   const unsigned char **out, unsigned char *outlen)

+{

+    const char *proposed;

+    size_t len;

+

+    /* The order the callbacks are invoked from TLS extensions is, unfortunately

+     * not defined and older openssl versions do call ALPN selection before

+     * they callback the SNI. We need to make sure that we know which vhost

+     * we are dealing with so we respect the correct protocols.

+     */

+    init_vhost(c, ssl);

+    

+    proposed = ap_select_protocol(c, NULL, sslconn->server, client_protos);

+    if (!proposed) {

+        proposed = ap_get_protocol(c);

+    }

+    

+    len = strlen(proposed);

+    if (len > 255) {

+        ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02840)

+                      "ALPN negotiated protocol name too long");

+        return SSL_TLSEXT_ERR_ALERT_FATAL;

+    }

+    *out = (const unsigned char *)proposed;

+    *outlen = (unsigned char)len;

+

+    ap_log_cerror(APLOG_MARK, APLOG_TRACE8, 0, c,

+		  "protocol switching from '%s' to '%s'",

+		  ap_get_protocol(c), proposed);

+        

+    if (strcmp(proposed, ap_get_protocol(c))) {

+        apr_status_t status;

+        

+        status = ap_switch_protocol(c, NULL, sslconn->server, proposed);

+        if (status != APR_SUCCESS) {

+            ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c,

+                          APLOGNO(02908) "protocol switch to '%s' failed",

+                          proposed);

+            return SSL_TLSEXT_ERR_ALERT_FATAL;

+        }

+    }

+

+    return SSL_TLSEXT_ERR_OK;

+}

+#endif /* defined(HAVE_TLS_NPN) || defined(HAVE_TLS_ALPN) */

+

+#ifdef HAVE_TLS_NPN

+/*

+ * This callback function is executed when SSL needs to decide what protocols

+ * to advertise during Next Protocol Negotiation (NPN).  It must produce a

+ * string in wire format -- a sequence of length-prefixed strings -- indicating

+ * the advertised protocols.  Refer to SSL_CTX_set_next_protos_advertised_cb

+ * in OpenSSL for reference.

+ */

+int ssl_callback_AdvertiseNextProtos(SSL *ssl, const unsigned char **data_out,

+                                     unsigned int *size_out, void *arg)

+{

+    conn_rec *c = (conn_rec*)SSL_get_app_data(ssl);

+    SSLConnRec *sslconn = myConnConfig(c);

+    const apr_array_header_t *protos;

+    int num_protos;

+    unsigned int size;

+    int i;

+    unsigned char *data;

+    unsigned char *start;

+

+    *data_out = NULL;

+    *size_out = 0;

+

+    /* If the connection object is not available, or there are no

+       upgrades available, do nothing. */

+    if (!c || ap_get_protocol_upgrades(c, NULL, sslconn->server, 0, &protos)) {

+	return SSL_TLSEXT_ERR_NOACK;

+    }

+

+    num_protos = protos ? protos->nelts : 0;

+

+    if (num_protos == 0) {

+        return SSL_TLSEXT_ERR_NOACK;

+    }

+

+    /* We now have a list of null-terminated strings; we need to concatenate

+     * them together into a single string, where each protocol name is prefixed

+     * by its length.  First, calculate how long that string will be. */

+    size = 0;

+    for (i = 0; i < num_protos; ++i) {

+        const char *string = APR_ARRAY_IDX(protos, i, const char*);

+        unsigned int length = strlen(string);

+        /* If the protocol name is too long (the length must fit in one byte),

+         * then log an error and skip it. */

+        if (length > 255) {

+            ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02307)

+                          "SSL NPN protocol name too long (length=%u): %s",

+                          length, string);

+            continue;

+        }

+        /* Leave room for the length prefix (one byte) plus the protocol name

+         * itself. */

+        size += 1 + length;

+    }

+

+    /* If there is nothing to advertise (either because no modules added

+     * anything to the protos array, or because all strings added to the array

+     * were skipped), then we're done. */

+    if (size == 0) {

+        return SSL_TLSEXT_ERR_OK;

+    }

+

+    /* Now we can build the string.  Copy each protocol name string into the

+     * larger string, prefixed by its length. */

+    data = apr_palloc(c->pool, size * sizeof(unsigned char));

+    start = data;

+    for (i = 0; i < num_protos; ++i) {

+        const char *string = APR_ARRAY_IDX(protos, i, const char*);

+        apr_size_t length = strlen(string);

+        if (length > 255)

+            continue;

+        *start = (unsigned char)length;

+        ++start;

+        memcpy(start, string, length * sizeof(unsigned char));

+        start += length;

+	ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, 

+		      "SSL NPN protocol advertising: %s", string);

+    }

+

+    /* Success. */

+    *data_out = data;

+    *size_out = size;

+    return SSL_TLSEXT_ERR_OK;

+}

+

+#endif /* HAVE_TLS_NPN */

+

 #ifdef HAVE_TLS_ALPN

 /*

@@ -2354,8 +2490,6 @@ int ssl_callback_alpn_select(SSL *ssl,

     conn_rec *c = (conn_rec*)SSL_get_app_data(ssl);

     SSLConnRec *sslconn = myConnConfig(c);

     apr_array_header_t *client_protos;

-    const char *proposed;

-    size_t len;

     int i;

     /* If the connection object is not available,

@@ -2385,40 +2519,7 @@ int ssl_callback_alpn_select(SSL *ssl,

         i += plen;

     }

-    /* The order the callbacks are invoked from TLS extensions is, unfortunately

-     * not defined and older openssl versions do call ALPN selection before

-     * they callback the SNI. We need to make sure that we know which vhost

-     * we are dealing with so we respect the correct protocols.

-     */

-    init_vhost(c, ssl);

-    

-    proposed = ap_select_protocol(c, NULL, sslconn->server, client_protos);

-    if (!proposed) {

-        proposed = ap_get_protocol(c);

-    }

-    

-    len = strlen(proposed);

-    if (len > 255) {

-        ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02840)

-                      "ALPN negotiated protocol name too long");

-        return SSL_TLSEXT_ERR_ALERT_FATAL;

-    }

-    *out = (const unsigned char *)proposed;

-    *outlen = (unsigned char)len;

-        

-    if (strcmp(proposed, ap_get_protocol(c))) {

-        apr_status_t status;

-        

-        status = ap_switch_protocol(c, NULL, sslconn->server, proposed);

-        if (status != APR_SUCCESS) {

-            ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c,

-                          APLOGNO(02908) "protocol switch to '%s' failed",

-                          proposed);

-            return SSL_TLSEXT_ERR_ALERT_FATAL;

-        }

-    }

-

-    return SSL_TLSEXT_ERR_OK;

+    return modssl_select_protocol(ssl, c, sslconn, client_protos, out, outlen);

 }

 #endif /* HAVE_TLS_ALPN */

diff --git a/modules/ssl/ssl_private.h b/modules/ssl/ssl_private.h

index 41b4387..7c440ef 100644

--- a/modules/ssl/ssl_private.h

+++ b/modules/ssl/ssl_private.h

@@ -98,6 +98,8 @@

 #include <openssl/x509_vfy.h>

 #include <openssl/ocsp.h>

+#include "mod_ssl.h"

+

 /* Avoid tripping over an engine build installed globally and detected

  * when the user points at an explicit non-engine flavor of OpenSSL

  */

@@ -127,6 +129,11 @@

 #define HAVE_FIPS

 #endif

+#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_NEXTPROTONEG) \

+    && !defined(OPENSSL_NO_TLSEXT)

+#define HAVE_TLS_NPN

+#endif

+

 #if defined(SSL_OP_NO_TLSv1_2)

 #define HAVE_TLSV1_X

 #endif

@@ -872,6 +879,10 @@ int          ssl_callback_ServerNameIndication(SSL *, int *, modssl_ctx_t *);

 int         ssl_callback_SessionTicket(SSL *, unsigned char *, unsigned char *,

                                        EVP_CIPHER_CTX *, HMAC_CTX *, int);

 #endif

+int ssl_callback_AdvertiseNextProtos(SSL *ssl, const unsigned char **data, unsigned int *len, void *arg);

+int modssl_select_protocol(SSL *ssl, conn_rec *c, SSLConnRec *sslconn,

+			   apr_array_header_t *client_protos,

+			   const unsigned char **out, unsigned char *outlen);

 #ifdef HAVE_TLS_ALPN

 int ssl_callback_alpn_select(SSL *ssl, const unsigned char **out,