v1.0.13 from apache trunk

Author: Stefan Eissing

Diff for: ChangeLog

@@ -1,3 +1,15 @@
+v1.0.13
+-------------------------------------------------------------------------------- 
+ * reworked connection state handling. Improved scoreboard update (server-status).
+   Default on H2KeepAliveTimeout same as H2Timeout, 5 seconds. After that, 
+   connections are closed.
+   On asynchronous MPMs (event), keep-alive connections no longer block threads,
+   but exact timeout handling is then up to the MPM. In these MPMs, having a
+   longer H2KeepAliveTimeout may be suitable.
+ * new CGI environment variables HTTP2 and H2PUSH. With former "on", the 
+   connection uses HTTP/2. With latter "on", the request may trigger Server Push
+   via Link headers, as both server and clients support it.
+
 v1.0.12
 -------------------------------------------------------------------------------- 
  * alpha release on top of Apache httpd 2.4.18

Diff for: configure.ac

@@ -14,7 +14,7 @@
 #
 
 AC_PREREQ([2.69])
-AC_INIT([mod_http2], [1.0.12], [[email protected]])
+AC_INIT([mod_http2], [1.0.13], [[email protected]])
 
 LT_PREREQ([2.2.6])
 LT_INIT()
@@ -122,6 +122,14 @@ HTTPD_VERSION="$($APXS -q HTTPD_VERSION)"
 AC_CHECK_LIB([nghttp2], [nghttp2_session_server_new2], ,
 [AC_MSG_ERROR("library nghttp2 not found")])
 
+AC_CHECK_HEADERS([nghttp2/nghttp2.h])
+# nghttp2 >= 1.3.0: access to stream weights
+AC_CHECK_FUNCS([nghttp2_stream_get_weight], 
+        [CPPFLAGS="$CPPFLAGS -DH2_NG2_STREAM_API"], [])
+# nghttp2 >= 1.5.0: changing stream priorities
+AC_CHECK_FUNCS([nghttp2_session_change_stream_priority], 
+        [CPPFLAGS="$CPPFLAGS -DH2_NG2_CHANGE_PRIO"], [])
+
 # Checks for header files.
 AC_CHECK_HEADERS([ \
     assert.h \

Diff for: mod_http2/.gitignore

@@ -3,5 +3,6 @@
 *.lo
 *.la
 .libs
+h2_version.h
 Makefile.in
 Makefile

Diff for: mod_http2/h2_config.c

@@ -60,12 +60,11 @@ static h2_config defconf = {
     1,                      /* HTTP/2 server push enabled */
     NULL,                   /* map of content-type to priorities */
     5,                      /* normal connection timeout */
-    5*60,                   /* idle connection timeout */
-    2*60,                   /* stream timeout */
+    5,                      /* keepalive timeout */
+    0,                      /* stream timeout */
 };
 
 static int files_per_session;
-static int async_mpm;
 
 void h2_config_init(apr_pool_t *pool)
 {
@@ -90,14 +89,6 @@ void h2_config_init(apr_pool_t *pool)
             /* don't know anything about it, stay safe */
             break;
     }
-    if (ap_mpm_query(AP_MPMQ_IS_ASYNC, &async_mpm) != APR_SUCCESS) {
-        async_mpm = 0;
-    }
-}
-
-int h2_config_async_mpm(void)
-{
-    return async_mpm;
 }
 
 static void *h2_config_create(apr_pool_t *pool,

Diff for: mod_http2/h2_config.h

@@ -95,7 +95,5 @@ void h2_config_init(apr_pool_t *pool);
 const struct h2_priority *h2_config_get_priority(const h2_config *conf, 
                                                  const char *content_type);
 
-int h2_config_async_mpm(void);
-
 #endif /* __mod_h2__h2_config_h__ */
 

Diff for: mod_http2/h2_conn.c

@@ -43,25 +43,31 @@ static struct h2_workers *workers;
 
 static h2_mpm_type_t mpm_type = H2_MPM_UNKNOWN;
 static module *mpm_module;
-static int checked;
+static int async_mpm;
 
-static void check_modules(void) 
+static void check_modules(int force) 
 {
+    static int checked = 0;
     int i;
-    if (!checked) {
+
+    if (force || !checked) {
         for (i = 0; ap_loaded_modules[i]; ++i) {
             module *m = ap_loaded_modules[i];
+            
             if (!strcmp("event.c", m->name)) {
                 mpm_type = H2_MPM_EVENT;
                 mpm_module = m;
+                break;
             }
             else if (!strcmp("worker.c", m->name)) {
                 mpm_type = H2_MPM_WORKER;
                 mpm_module = m;
+                break;
             }
             else if (!strcmp("prefork.c", m->name)) {
                 mpm_type = H2_MPM_PREFORK;
                 mpm_module = m;
+                break;
             }
         }
         checked = 1;
@@ -72,40 +78,34 @@ apr_status_t h2_conn_child_init(apr_pool_t *pool, server_rec *s)
 {
     const h2_config *config = h2_config_sget(s);
     apr_status_t status = APR_SUCCESS;
-    int minw = h2_config_geti(config, H2_CONF_MIN_WORKERS);
-    int maxw = h2_config_geti(config, H2_CONF_MAX_WORKERS);    
+    int minw, maxw;
     int max_threads_per_child = 0;
     int idle_secs = 0;
-    int i;
 
-    h2_config_init(pool);
+    check_modules(1);
 
     ap_mpm_query(AP_MPMQ_MAX_THREADS, &max_threads_per_child);
 
-    for (i = 0; ap_loaded_modules[i]; ++i) {
-        module *m = ap_loaded_modules[i];
-        if (!strcmp("event.c", m->name)) {
-            mpm_type = H2_MPM_EVENT;
-            mpm_module = m;
-        }
-        else if (!strcmp("worker.c", m->name)) {
-            mpm_type = H2_MPM_WORKER;
-            mpm_module = m;
-        }
-        else if (!strcmp("prefork.c", m->name)) {
-            mpm_type = H2_MPM_PREFORK;
-            mpm_module = m;
-        }
+    status = ap_mpm_query(AP_MPMQ_IS_ASYNC, &async_mpm);
+    if (status != APR_SUCCESS) {
+        ap_log_error(APLOG_MARK, APLOG_TRACE1, status, s, "querying MPM for async");
+        /* some MPMs do not implemnent this */
+        async_mpm = 0;
+        status = APR_SUCCESS;
     }
+
+    h2_config_init(pool);
 
+    minw = h2_config_geti(config, H2_CONF_MIN_WORKERS);
+    maxw = h2_config_geti(config, H2_CONF_MAX_WORKERS);    
     if (minw <= 0) {
         minw = max_threads_per_child;
     }
     if (maxw <= 0) {
         maxw = minw;
     }
 
-    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
+    ap_log_error(APLOG_MARK, APLOG_TRACE3, 0, s,
                  "h2_workers: min=%d max=%d, mthrpchild=%d", 
                  minw, maxw, max_threads_per_child);
 
@@ -119,21 +119,22 @@ apr_status_t h2_conn_child_init(apr_pool_t *pool, server_rec *s)
     return status;
 }
 
-h2_mpm_type_t h2_conn_mpm_type(void) {
-    check_modules();
+h2_mpm_type_t h2_conn_mpm_type(void)
+{
+    check_modules(0);
     return mpm_type;
 }
 
-static module *h2_conn_mpm_module(void) {
-    check_modules();
+static module *h2_conn_mpm_module(void)
+{
+    check_modules(0);
     return mpm_module;
 }
 
 apr_status_t h2_conn_setup(h2_ctx *ctx, conn_rec *c, request_rec *r)
 {
     h2_session *session;
 
-    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, "setup");
     if (!workers) {
         ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02911) 
                       "workers not initialized");
@@ -154,45 +155,48 @@ apr_status_t h2_conn_setup(h2_ctx *ctx, conn_rec *c, request_rec *r)
     return APR_SUCCESS;
 }
 
-apr_status_t h2_conn_process(h2_ctx *ctx, int async)
+static apr_status_t h2_conn_process(h2_ctx *ctx)
 {
-    apr_status_t status;
     h2_session *session;
 
     session = h2_ctx_session_get(ctx);
     if (session->c->cs) {
         session->c->cs->sense = CONN_SENSE_DEFAULT;
     }
 
-    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, "process");
-    status = h2_session_process(session, async);
+    h2_session_process(session, async_mpm);
 
+    session->c->keepalive = AP_CONN_KEEPALIVE;
     if (session->c->cs) {
         session->c->cs->state = CONN_STATE_WRITE_COMPLETION;
     }
 
-    if (status == APR_EOF) {
-        ap_log_cerror( APLOG_MARK, APLOG_DEBUG, status, session->c,
+    if (session->state == H2_SESSION_ST_CLOSING) {
+        ap_log_cerror( APLOG_MARK, APLOG_DEBUG, 0, session->c,
                       "h2_session(%ld): done", session->id);
         /* Make sure this connection gets closed properly. */
         ap_update_child_status_from_conn(session->c->sbh, SERVER_CLOSING, session->c);
         session->c->keepalive = AP_CONN_CLOSE;
 
         h2_session_close(session);
-        /* hereafter session will be gone */
-    }
-    else {
-        session->c->keepalive = AP_CONN_KEEPALIVE;
+        /* hereafter session may be gone */
     }
 
     return DONE;
 }
 
 apr_status_t h2_conn_run(struct h2_ctx *ctx, conn_rec *c)
 {
+    int mpm_state = 0;
     do {
-        h2_conn_process(ctx, 0);
-    } while (c->keepalive == AP_CONN_KEEPALIVE && !c->aborted);
+        h2_conn_process(ctx);
+        
+        if (ap_mpm_query(AP_MPMQ_MPM_STATE, &mpm_state)) {
+            break;
+        }
+    } while (!async_mpm 
+             && c->keepalive == AP_CONN_KEEPALIVE 
+             && mpm_state != AP_MPMQ_STOPPING);
 
     return DONE;
 }

Diff for: mod_http2/h2_conn.h

@@ -28,16 +28,6 @@ struct h2_task;
  */
 apr_status_t h2_conn_setup(struct h2_ctx *ctx, conn_rec *c, request_rec *r);
 
-/**
- * Process the HTTP/2 connection. Return whenever blocking reads or
- * long writes have to be performed.
- *
- * @param ctx the http2 context to process
- * @return APR_SUCCESS as long as processing needs to continue, APR_EOF
- *         when HTTP/2 session is done.
- */
-apr_status_t h2_conn_process(struct h2_ctx *ctx, int async);
-
 /**
  * Run the HTTP/2 connection in synchronous fashion. 
  * Return when the HTTP/2 session is done

Diff for: mod_http2/h2_conn_io.c

@@ -79,7 +79,7 @@ apr_status_t h2_conn_io_init(h2_conn_io *io, conn_rec *c,
     }
 
     if (APLOGctrace1(c)) {
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io(%ld): init, buffering=%d, warmup_size=%ld, cd_secs=%f",
                       io->connection->id, io->buffer_output, (long)io->warmup_size,
                       ((float)io->cooldown_usecs/APR_USEC_PER_SEC));
@@ -106,7 +106,7 @@ static apr_status_t pass_out(apr_bucket_brigade *bb, void *ctx)
     ap_update_child_status(io->connection->sbh, SERVER_BUSY_WRITE, NULL);
     status = apr_brigade_length(bb, 0, &bblen);
     if (status == APR_SUCCESS) {
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io(%ld): pass_out brigade %ld bytes",
                       io->connection->id, (long)bblen);
         status = ap_pass_brigade(io->connection->output_filters, bb);
@@ -135,15 +135,15 @@ static apr_status_t bucketeer_buffer(h2_conn_io *io)
         /* long time not written, reset write size */
         io->write_size = WRITE_SIZE_INITIAL;
         io->bytes_written = 0;
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io(%ld): timeout write size reset to %ld", 
                       (long)io->connection->id, (long)io->write_size);
     }
     else if (io->write_size < WRITE_SIZE_MAX 
              && io->bytes_written >= io->warmup_size) {
         /* connection is hot, use max size */
         io->write_size = WRITE_SIZE_MAX;
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io(%ld): threshold reached, write size now %ld", 
                       (long)io->connection->id, (long)io->write_size);
     }
@@ -172,7 +172,7 @@ apr_status_t h2_conn_io_write(h2_conn_io *io,
 
     io->unflushed = 1;
     if (io->bufsize > 0) {
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io: buffering %ld bytes", (long)length);
 
         if (!APR_BRIGADE_EMPTY(io->output)) {
@@ -203,7 +203,7 @@ apr_status_t h2_conn_io_write(h2_conn_io *io,
 
     }
     else {
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, status, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, status, io->connection,
                       "h2_conn_io: writing %ld bytes to brigade", (long)length);
         status = apr_brigade_write(io->output, pass_out, io, buf, length);
     }
@@ -247,7 +247,7 @@ static apr_status_t h2_conn_io_flush_int(h2_conn_io *io, int force)
     if (io->unflushed || force) {
         if (io->buflen > 0) {
             /* something in the buffer, put it in the output brigade */
-            ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, io->connection,
+            ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                           "h2_conn_io: flush, flushing %ld bytes", (long)io->buflen);
             bucketeer_buffer(io);
             io->buflen = 0;
@@ -258,7 +258,7 @@ static apr_status_t h2_conn_io_flush_int(h2_conn_io *io, int force)
                                     apr_bucket_flush_create(io->output->bucket_alloc));
         }
 
-        ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, io->connection,
+        ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, io->connection,
                       "h2_conn_io: flush");
         /* Send it out */
         io->unflushed = 0;
@@ -279,17 +279,3 @@ apr_status_t h2_conn_io_pass(h2_conn_io *io)
     return h2_conn_io_flush_int(io, 0);
 }
 
-apr_status_t h2_conn_io_close(h2_conn_io *io, void *session)
-{
-    apr_bucket *b;
-
-    /* Send out anything in our buffers */
-    h2_conn_io_flush_int(io, 0);
-    
-    b = h2_bucket_eoc_create(io->connection->bucket_alloc, session);
-    APR_BRIGADE_INSERT_TAIL(io->output, b);
-    b = apr_bucket_flush_create(io->connection->bucket_alloc);
-    APR_BRIGADE_INSERT_TAIL(io->output, b);
-    return ap_pass_brigade(io->connection->output_filters, io->output);
-    /* and all is gone */
-}

Diff for: mod_http2/h2_conn_io.h

@@ -60,6 +60,5 @@ apr_status_t h2_conn_io_consider_flush(h2_conn_io *io);
 
 apr_status_t h2_conn_io_pass(h2_conn_io *io);
 apr_status_t h2_conn_io_flush(h2_conn_io *io);
-apr_status_t h2_conn_io_close(h2_conn_io *io, void *session);
 
 #endif /* defined(__mod_h2__h2_conn_io__) */