/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <assert.h>

#include <stddef.h>

#include <apr_thread_cond.h>

#include <apr_base64.h>

#include <apr_strings.h>

#include <ap_mpm.h>

#include <httpd.h>

#include <http_core.h>

#include <http_config.h>

#include <http_log.h>

#include <scoreboard.h>

#include <mpm_common.h>

#include "h2_private.h"

#include "h2.h"

#include "h2_bucket_beam.h"

#include "h2_bucket_eos.h"

#include "h2_config.h"

#include "h2_ctx.h"

#include "h2_filter.h"

#include "h2_h2.h"

#include "h2_mplx.h"

#include "h2_push.h"

#include "h2_request.h"

#include "h2_headers.h"

#include "h2_stream.h"

#include "h2_task.h"

#include "h2_session.h"

#include "h2_util.h"

#include "h2_version.h"

#include "h2_workers.h"

static apr_status_t dispatch_master(h2_session *session);

static apr_status_t h2_session_read(h2_session *session, int block);

static void transit(h2_session *session, const char *action, 

                    h2_session_state nstate);

static void on_stream_state_enter(void *ctx, h2_stream *stream);

static void on_stream_state_event(void *ctx, h2_stream *stream, h2_stream_event_t ev);

static void on_stream_event(void *ctx, h2_stream *stream, h2_stream_event_t ev);

static int h2_session_status_from_apr_status(apr_status_t rv)

{

    if (rv == APR_SUCCESS) {

        return NGHTTP2_NO_ERROR;

    }

    else if (APR_STATUS_IS_EAGAIN(rv)) {

        return NGHTTP2_ERR_WOULDBLOCK;

    }

    else if (APR_STATUS_IS_EOF(rv)) {

        return NGHTTP2_ERR_EOF;

    }

    return NGHTTP2_ERR_PROTO;

}

h2_stream *h2_session_stream_get(h2_session *session, int stream_id)

{

    return nghttp2_session_get_stream_user_data(session->ngh2, stream_id);

}

static void dispatch_event(h2_session *session, h2_session_event_t ev, 

                             int err, const char *msg);

void h2_session_event(h2_session *session, h2_session_event_t ev, 

                             int err, const char *msg)

{

    dispatch_event(session, ev, err, msg);

}

static int rst_unprocessed_stream(h2_stream *stream, void *ctx)

{

    int unprocessed = (!h2_stream_was_closed(stream)

                       && (H2_STREAM_CLIENT_INITIATED(stream->id)? 

                           (!stream->session->local.accepting

                            && stream->id > stream->session->local.accepted_max)

                            : 

                           (!stream->session->remote.accepting

                            && stream->id > stream->session->remote.accepted_max))

                       ); 

    if (unprocessed) {

        h2_stream_rst(stream, H2_ERR_NO_ERROR);

        return 0;

    }

    return 1;

}

static void cleanup_unprocessed_streams(h2_session *session)

{

    h2_mplx_stream_do(session->mplx, rst_unprocessed_stream, session);

}

static h2_stream *h2_session_open_stream(h2_session *session, int stream_id,

                                         int initiated_on)

{

    h2_stream * stream;

    apr_pool_t *stream_pool;

    apr_pool_create(&stream_pool, session->pool);

    apr_pool_tag(stream_pool, "h2_stream");

    stream = h2_stream_create(stream_id, stream_pool, session, 

                              session->monitor, initiated_on);

    if (stream) {

        nghttp2_session_set_stream_user_data(session->ngh2, stream_id, stream);

    }

    return stream;

}

/**

 * Determine the importance of streams when scheduling tasks.

 * - if both stream depend on the same one, compare weights

 * - if one stream is closer to the root, prioritize that one

 * - if both are on the same level, use the weight of their root

 *   level ancestors

 */

static int spri_cmp(int sid1, nghttp2_stream *s1, 

                    int sid2, nghttp2_stream *s2, h2_session *session)

{

    nghttp2_stream *p1, *p2;

    p1 = nghttp2_stream_get_parent(s1);

    p2 = nghttp2_stream_get_parent(s2);

    if (p1 == p2) {

        int32_t w1, w2;

        w1 = nghttp2_stream_get_weight(s1);

        w2 = nghttp2_stream_get_weight(s2);

        return w2 - w1;

    }

    else if (!p1) {

        /* stream 1 closer to root */

        return -1;

    }

    else if (!p2) {

        /* stream 2 closer to root */

        return 1;

    }

    return spri_cmp(sid1, p1, sid2, p2, session);

}

static int stream_pri_cmp(int sid1, int sid2, void *ctx)

{

    h2_session *session = ctx;

    nghttp2_stream *s1, *s2;

    s1 = nghttp2_session_find_stream(session->ngh2, sid1);

    s2 = nghttp2_session_find_stream(session->ngh2, sid2);

    if (s1 == s2) {

        return 0;

    }

    else if (!s1) {

        return 1;

    }

    else if (!s2) {

        return -1;

    }

    return spri_cmp(sid1, s1, sid2, s2, session);

}

/*

 * Callback when nghttp2 wants to send bytes back to the client.

 */

static ssize_t send_cb(nghttp2_session *ngh2,

                       const uint8_t *data, size_t length,

                       int flags, void *userp)

{

    h2_session *session = (h2_session *)userp;

    apr_status_t status;

    (void)ngh2;

    (void)flags;

    status = h2_conn_io_write(&session->io, (const char *)data, length);

    if (status == APR_SUCCESS) {

        return length;

    }

    if (APR_STATUS_IS_EAGAIN(status)) {

        return NGHTTP2_ERR_WOULDBLOCK;

    }

    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, session->c, APLOGNO(03062)

                  "h2_session: send error");

    return h2_session_status_from_apr_status(status);

}

static int on_invalid_frame_recv_cb(nghttp2_session *ngh2,

                                    const nghttp2_frame *frame,

                                    int error, void *userp)

{

    h2_session *session = (h2_session *)userp;

    (void)ngh2;

    if (APLOGcdebug(session->c)) {

        char buffer[256];

        h2_util_frame_print(frame, buffer, sizeof(buffer)/sizeof(buffer[0]));

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, 

                      H2_SSSN_LOG(APLOGNO(03063), session, 

                      "recv invalid FRAME[%s], frames=%ld/%ld (r/s)"),

                      buffer, (long)session->frames_received,

                     (long)session->frames_sent);

    }

    return 0;

}

static int on_data_chunk_recv_cb(nghttp2_session *ngh2, uint8_t flags,

                                 int32_t stream_id,

                                 const uint8_t *data, size_t len, void *userp)

{

    h2_session *session = (h2_session *)userp;

    apr_status_t status = APR_EINVAL;

    h2_stream * stream;

    int rv = 0;

    stream = h2_session_stream_get(session, stream_id);

    if (stream) {

        status = h2_stream_recv_DATA(stream, flags, data, len);

        dispatch_event(session, H2_SESSION_EV_STREAM_CHANGE, 0, "stream data rcvd");

    }

    else {

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, APLOGNO(03064)

                      "h2_stream(%ld-%d): on_data_chunk for unknown stream",

                      session->id, (int)stream_id);

        rv = NGHTTP2_ERR_CALLBACK_FAILURE;

    }

    if (status != APR_SUCCESS) {

        /* count this as consumed explicitly as no one will read it */

        nghttp2_session_consume(session->ngh2, stream_id, len);

    }

    return rv;

}

static int on_stream_close_cb(nghttp2_session *ngh2, int32_t stream_id,

                              uint32_t error_code, void *userp)

{

    h2_session *session = (h2_session *)userp;

    h2_stream *stream;

    (void)ngh2;

    stream = h2_session_stream_get(session, stream_id);

    if (stream) {

        if (error_code) {

            ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,

                          H2_STRM_LOG(APLOGNO(03065), stream, 

                          "closing with err=%d %s"), 

                          (int)error_code, h2_h2_err_description(error_code));

            h2_stream_rst(stream, error_code);

        }

    }

    return 0;

}

static int on_begin_headers_cb(nghttp2_session *ngh2,

                               const nghttp2_frame *frame, void *userp)

{

    h2_session *session = (h2_session *)userp;

    h2_stream *s;

    /* We may see HEADERs at the start of a stream or after all DATA

     * streams to carry trailers. */

    (void)ngh2;

    s = h2_session_stream_get(session, frame->hd.stream_id);

    if (s) {

        /* nop */

    }

    else {

        s = h2_session_open_stream(userp, frame->hd.stream_id, 0);

    }

    return s? 0 : NGHTTP2_ERR_START_STREAM_NOT_ALLOWED;

}

static int on_header_cb(nghttp2_session *ngh2, const nghttp2_frame *frame,

                        const uint8_t *name, size_t namelen,

                        const uint8_t *value, size_t valuelen,

                        uint8_t flags,

                        void *userp)

{

    h2_session *session = (h2_session *)userp;

    h2_stream * stream;

    apr_status_t status;

    (void)flags;

    stream = h2_session_stream_get(session, frame->hd.stream_id);

    if (!stream) {

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, APLOGNO(02920) 

                      "h2_stream(%ld-%d): on_header unknown stream",

                      session->id, (int)frame->hd.stream_id);

        return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;

    }

    status = h2_stream_add_header(stream, (const char *)name, namelen,

                                  (const char *)value, valuelen);

    if (status != APR_SUCCESS && !h2_stream_is_ready(stream)) {

        return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;

    }

    return 0;

}

/**

 * nghttp2 session has received a complete frame. Most are used by nghttp2

 * for processing of internal state. Some, like HEADER and DATA frames,

 * we need to act on.

 */

static int on_frame_recv_cb(nghttp2_session *ng2s,

                            const nghttp2_frame *frame,

                            void *userp)

{

    h2_session *session = (h2_session *)userp;

    h2_stream *stream;

    apr_status_t rv = APR_SUCCESS;

    if (APLOGcdebug(session->c)) {

        char buffer[256];

        h2_util_frame_print(frame, buffer, sizeof(buffer)/sizeof(buffer[0]));

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, 

                      H2_SSSN_LOG(APLOGNO(03066), session, 

                      "recv FRAME[%s], frames=%ld/%ld (r/s)"),

                      buffer, (long)session->frames_received,

                     (long)session->frames_sent);

    }

    ++session->frames_received;

    switch (frame->hd.type) {

        case NGHTTP2_HEADERS:

            /* This can be HEADERS for a new stream, defining the request,

             * or HEADER may come after DATA at the end of a stream as in

             * trailers */

            stream = h2_session_stream_get(session, frame->hd.stream_id);

            if (stream) {

                rv = h2_stream_recv_frame(stream, NGHTTP2_HEADERS, frame->hd.flags, 

                    frame->hd.length + H2_FRAME_HDR_LEN);

            }

            break;

        case NGHTTP2_DATA:

            stream = h2_session_stream_get(session, frame->hd.stream_id);

            if (stream) {

                ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,  

                              H2_STRM_LOG(APLOGNO(02923), stream, 

                              "DATA, len=%ld, flags=%d"), 

                              (long)frame->hd.length, frame->hd.flags);

                rv = h2_stream_recv_frame(stream, NGHTTP2_DATA, frame->hd.flags, 

                    frame->hd.length + H2_FRAME_HDR_LEN);

            }

            break;

        case NGHTTP2_PRIORITY:

            session->reprioritize = 1;

            ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,

                          "h2_stream(%ld-%d): PRIORITY frame "

                          " weight=%d, dependsOn=%d, exclusive=%d", 

                          session->id, (int)frame->hd.stream_id,

                          frame->priority.pri_spec.weight,

                          frame->priority.pri_spec.stream_id,

                          frame->priority.pri_spec.exclusive);

            break;

        case NGHTTP2_WINDOW_UPDATE:

            ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,

                          "h2_stream(%ld-%d): WINDOW_UPDATE incr=%d", 

                          session->id, (int)frame->hd.stream_id,

                          frame->window_update.window_size_increment);

            if (nghttp2_session_want_write(session->ngh2)) {

                dispatch_event(session, H2_SESSION_EV_FRAME_RCVD, 0, "window update");

            }

            break;

        case NGHTTP2_RST_STREAM:

            ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, APLOGNO(03067)

                          "h2_stream(%ld-%d): RST_STREAM by client, errror=%d",

                          session->id, (int)frame->hd.stream_id,

                          (int)frame->rst_stream.error_code);

            stream = h2_session_stream_get(session, frame->hd.stream_id);

            if (stream && stream->initiated_on) {

                ++session->pushes_reset;

            }

            else {

                ++session->streams_reset;

            }

            break;

        case NGHTTP2_GOAWAY:

            if (frame->goaway.error_code == 0 

                && frame->goaway.last_stream_id == ((1u << 31) - 1)) {

                /* shutdown notice. Should not come from a client... */

                session->remote.accepting = 0;

            }

            else {

                session->remote.accepted_max = frame->goaway.last_stream_id;

                dispatch_event(session, H2_SESSION_EV_REMOTE_GOAWAY, 

                               frame->goaway.error_code, NULL);

            }

            break;

        case NGHTTP2_SETTINGS:

            if (APLOGctrace2(session->c)) {

                ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,

                              H2_SSSN_MSG(session, "SETTINGS, len=%ld"), (long)frame->hd.length);

            }

            break;

        default:

            if (APLOGctrace2(session->c)) {

                char buffer[256];

                h2_util_frame_print(frame, buffer,

                                    sizeof(buffer)/sizeof(buffer[0]));

                ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,

                              H2_SSSN_MSG(session, "on_frame_rcv %s"), buffer);

            }

            break;

    }

    if (session->state == H2_SESSION_ST_IDLE) {

        /* We received a frame, but session is in state IDLE. That means the frame

         * did not really progress any of the (possibly) open streams. It was a meta

         * frame, e.g. SETTINGS/WINDOW_UPDATE/unknown/etc.

         * Remember: IDLE means we cannot send because either there are no streams open or

         * all open streams are blocked on exhausted WINDOWs for outgoing data.

         * The more frames we receive that do not change this, the less interested we

         * become in serving this connection. This is expressed in increasing "idle_delays".

         * Eventually, the connection will timeout and we'll close it. */

        session->idle_frames = H2MIN(session->idle_frames + 1, session->frames_received);

            ap_log_cerror( APLOG_MARK, APLOG_TRACE2, 0, session->c,

                          H2_SSSN_MSG(session, "session has %ld idle frames"), 

                          (long)session->idle_frames);

        if (session->idle_frames > 10) {

            apr_size_t busy_frames = H2MAX(session->frames_received - session->idle_frames, 1);

            int idle_ratio = (int)(session->idle_frames / busy_frames); 

            if (idle_ratio > 100) {

                session->idle_delay = apr_time_from_msec(H2MIN(1000, idle_ratio));

            }

            else if (idle_ratio > 10) {

                session->idle_delay = apr_time_from_msec(10);

            }

            else if (idle_ratio > 1) {

                session->idle_delay = apr_time_from_msec(1);

            }

            else {

                session->idle_delay = 0;

            }

        }

    }

    if (APR_SUCCESS != rv) return NGHTTP2_ERR_PROTO;

    return 0;

}

static int h2_session_continue_data(h2_session *session) {

    if (h2_mplx_has_master_events(session->mplx)) {

        return 0;

    }

    if (h2_conn_io_needs_flush(&session->io)) {

        return 0;

    }

    return 1;

}

static char immortal_zeros[H2_MAX_PADLEN];

static int on_send_data_cb(nghttp2_session *ngh2, 

                           nghttp2_frame *frame, 

                           const uint8_t *framehd, 

                           size_t length, 

                           nghttp2_data_source *source, 

                           void *userp)

{

    apr_status_t status = APR_SUCCESS;

    h2_session *session = (h2_session *)userp;

    int stream_id = (int)frame->hd.stream_id;

    unsigned char padlen;

    int eos;

    h2_stream *stream;

    apr_bucket *b;

    apr_off_t len = length;

    (void)ngh2;

    (void)source;

    if (!h2_session_continue_data(session)) {

        return NGHTTP2_ERR_WOULDBLOCK;

    }

    if (frame->data.padlen > H2_MAX_PADLEN) {

        return NGHTTP2_ERR_PROTO;

    }

    padlen = (unsigned char)frame->data.padlen;

    stream = h2_session_stream_get(session, stream_id);

    if (!stream) {

        ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_NOTFOUND, session->c,

                      APLOGNO(02924) 

                      "h2_stream(%ld-%d): send_data, stream not found",

                      session->id, (int)stream_id);

        return NGHTTP2_ERR_CALLBACK_FAILURE;

    }

    ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,

                  H2_STRM_MSG(stream, "send_data_cb for %ld bytes"),

                  (long)length);

    status = h2_conn_io_write(&session->io, (const char *)framehd, 9);

    if (padlen && status == APR_SUCCESS) {

        status = h2_conn_io_write(&session->io, (const char *)&padlen, 1);

    }

    if (status != APR_SUCCESS) {

        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, session->c,

                      H2_STRM_MSG(stream, "writing frame header"));

        return NGHTTP2_ERR_CALLBACK_FAILURE;

    }

    status = h2_stream_read_to(stream, session->bbtmp, &len, &eos;;

    if (status != APR_SUCCESS) {

        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, session->c,

                      H2_STRM_MSG(stream, "send_data_cb, reading stream"));

        apr_brigade_cleanup(session->bbtmp);

        return NGHTTP2_ERR_CALLBACK_FAILURE;

    }

    else if (len != length) {

        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, session->c,

                      H2_STRM_MSG(stream, "send_data_cb, wanted %ld bytes, "

                      "got %ld from stream"), (long)length, (long)len);

        apr_brigade_cleanup(session->bbtmp);

        return NGHTTP2_ERR_CALLBACK_FAILURE;

    }

    if (padlen) {

        b = apr_bucket_immortal_create(immortal_zeros, padlen, 

                                       session->c->bucket_alloc);

        APR_BRIGADE_INSERT_TAIL(session->bbtmp, b);

    }

    status = h2_conn_io_pass(&session->io, session->bbtmp);

    apr_brigade_cleanup(session->bbtmp);

    if (status == APR_SUCCESS) {

        stream->out_data_frames++;

        stream->out_data_octets += length;

        return 0;

    }

    else {

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, session->c,  

                      H2_STRM_LOG(APLOGNO(02925), stream, "failed send_data_cb"));

        return NGHTTP2_ERR_CALLBACK_FAILURE;

    }

}

static int on_frame_send_cb(nghttp2_session *ngh2, 

                            const nghttp2_frame *frame,

                            void *user_data)

{

    h2_session *session = user_data;

    h2_stream *stream;

    int stream_id = frame->hd.stream_id;

    ++session->frames_sent;

    switch (frame->hd.type) {

        case NGHTTP2_PUSH_PROMISE:

            /* PUSH_PROMISE we report on the promised stream */

            stream_id = frame->push_promise.promised_stream_id;

            break;

        default:    

            break;

    }

    if (APLOGcdebug(session->c)) {

        char buffer[256];

        h2_util_frame_print(frame, buffer, sizeof(buffer)/sizeof(buffer[0]));

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, 

                      H2_SSSN_LOG(APLOGNO(03068), session, 

                      "sent FRAME[%s], frames=%ld/%ld (r/s)"),

                      buffer, (long)session->frames_received,

                     (long)session->frames_sent);

    }

    stream = h2_session_stream_get(session, stream_id);

    if (stream) {

        h2_stream_send_frame(stream, frame->hd.type, frame->hd.flags, 

            frame->hd.length + H2_FRAME_HDR_LEN);

    }

    return 0;

}

#ifdef H2_NG2_INVALID_HEADER_CB

static int on_invalid_header_cb(nghttp2_session *ngh2, 

                                const nghttp2_frame *frame, 

                                const uint8_t *name, size_t namelen, 

                                const uint8_t *value, size_t valuelen, 

                                uint8_t flags, void *user_data)

{

    h2_session *session = user_data;

    h2_stream *stream;

    if (APLOGcdebug(session->c)) {

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, APLOGNO(03456)

                      "h2_stream(%ld-%d): invalid header '%s: %s'", 

                      session->id, (int)frame->hd.stream_id,

                      apr_pstrndup(session->pool, (const char *)name, namelen),

                      apr_pstrndup(session->pool, (const char *)value, valuelen));

    }

    stream = h2_session_stream_get(session, frame->hd.stream_id);

    if (stream) {

        h2_stream_rst(stream, NGHTTP2_PROTOCOL_ERROR);

    }

    return 0;

}

#endif

#define NGH2_SET_CALLBACK(callbacks, name, fn)\

nghttp2_session_callbacks_set_##name##_callback(callbacks, fn)

static apr_status_t init_callbacks(conn_rec *c, nghttp2_session_callbacks **pcb)

{

    int rv = nghttp2_session_callbacks_new(pcb);

    if (rv != 0) {

        ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c,

                      APLOGNO(02926) "nghttp2_session_callbacks_new: %s",

                      nghttp2_strerror(rv));

        return APR_EGENERAL;

    }

    NGH2_SET_CALLBACK(*pcb, send, send_cb);

    NGH2_SET_CALLBACK(*pcb, on_frame_recv, on_frame_recv_cb);

    NGH2_SET_CALLBACK(*pcb, on_invalid_frame_recv, on_invalid_frame_recv_cb);

    NGH2_SET_CALLBACK(*pcb, on_data_chunk_recv, on_data_chunk_recv_cb);

    NGH2_SET_CALLBACK(*pcb, on_stream_close, on_stream_close_cb);

    NGH2_SET_CALLBACK(*pcb, on_begin_headers, on_begin_headers_cb);

    NGH2_SET_CALLBACK(*pcb, on_header, on_header_cb);

    NGH2_SET_CALLBACK(*pcb, send_data, on_send_data_cb);

    NGH2_SET_CALLBACK(*pcb, on_frame_send, on_frame_send_cb);

#ifdef H2_NG2_INVALID_HEADER_CB

    NGH2_SET_CALLBACK(*pcb, on_invalid_header, on_invalid_header_cb);

#endif

    return APR_SUCCESS;

}

static apr_status_t h2_session_shutdown_notice(h2_session *session)

{

    apr_status_t status;

    ap_assert(session);

    if (!session->local.accepting) {

        return APR_SUCCESS;

    }

    nghttp2_submit_shutdown_notice(session->ngh2);

    session->local.accepting = 0;

    status = nghttp2_session_send(session->ngh2);

    if (status == APR_SUCCESS) {

        status = h2_conn_io_flush(&session->io);

    }

    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, 

                  H2_SSSN_LOG(APLOGNO(03457), session, "sent shutdown notice"));

    return status;

}

static apr_status_t h2_session_shutdown(h2_session *session, int error, 

                                        const char *msg, int force_close)

{

    apr_status_t status = APR_SUCCESS;

    ap_assert(session);

    if (session->local.shutdown) {

        return APR_SUCCESS;

    }

    if (!msg && error) {

        msg = nghttp2_strerror(error);

    }

    if (error || force_close) {

        /* not a graceful shutdown, we want to leave... 

         * Do not start further streams that are waiting to be scheduled. 

         * Find out the max stream id that we habe been processed or

         * are still actively working on.

         * Remove all streams greater than this number without submitting

         * a RST_STREAM frame, since that should be clear from the GOAWAY

         * we send. */

        session->local.accepted_max = h2_mplx_shutdown(session->mplx);

        session->local.error = error;

    }

    else {

        /* graceful shutdown. we will continue processing all streams

         * we have, but no longer accept new ones. Report the max stream

         * we have received and discard all new ones. */

    }

    session->local.accepting = 0;

    session->local.shutdown = 1;

    if (!session->c->aborted) {

        nghttp2_submit_goaway(session->ngh2, NGHTTP2_FLAG_NONE, 

                              session->local.accepted_max, 

                              error, (uint8_t*)msg, msg? strlen(msg):0);

        status = nghttp2_session_send(session->ngh2);

        if (status == APR_SUCCESS) {

            status = h2_conn_io_flush(&session->io);

        }

        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c, 

                      H2_SSSN_LOG(APLOGNO(03069), session, 

                                  "sent GOAWAY, err=%d, msg=%s"), error, msg? msg : "");

    }

    dispatch_event(session, H2_SESSION_EV_LOCAL_GOAWAY, error, msg);

    return status;

}

static apr_status_t session_cleanup(h2_session *session, const char *trigger)

{

    conn_rec *c = session->c;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c,

                  H2_SSSN_MSG(session, "pool_cleanup"));

    if (session->state != H2_SESSION_ST_DONE

        && session->state != H2_SESSION_ST_INIT) {

        /* Not good. The connection is being torn down and we have

         * not sent a goaway. This is considered a protocol error and

         * the client has to assume that any streams "in flight" may have

         * been processed and are not safe to retry.

         * As clients with idle connection may only learn about a closed

         * connection when sending the next request, this has the effect

         * that at least this one request will fail.

         */

        ap_log_cerror(APLOG_MARK, APLOG_WARNING, 0, c,

                      H2_SSSN_LOG(APLOGNO(03199), session, 

                      "connection disappeared without proper "

                      "goodbye, clients will be confused, should not happen"));

    }

    transit(session, trigger, H2_SESSION_ST_CLEANUP);

    h2_mplx_release_and_join(session->mplx, session->iowait);

    session->mplx = NULL;

    ap_assert(session->ngh2);

    nghttp2_session_del(session->ngh2);

    session->ngh2 = NULL;

    h2_ctx_clear(c);

    return APR_SUCCESS;

}

static apr_status_t session_pool_cleanup(void *data)

{

    conn_rec *c = data;

    h2_session *session;

    h2_ctx *ctx = h2_ctx_get(c, 0);

    if (ctx && (session = h2_ctx_session_get(ctx))) {

        /* if the session is still there, now is the last chance

         * to perform cleanup. Normally, cleanup should have happened

         * earlier in the connection pre_close. Main reason is that

         * any ongoing requests on slave connections might still access

         * data which has, at this time, already been freed. An example

         * is mod_ssl that uses request hooks. */

        ap_log_cerror(APLOG_MARK, APLOG_WARNING, 0, c,

                      H2_SSSN_LOG(APLOGNO(10020), session, 

                      "session cleanup triggered by pool cleanup. "

                      "this should have happened earlier already."));

        return session_cleanup(session, "pool cleanup");

    }

    return APR_SUCCESS;

}

static apr_status_t h2_session_create_int(h2_session **psession,

                                          conn_rec *c,

                                          request_rec *r,

                                          h2_ctx *ctx, 

                                          h2_workers *workers)

{

    nghttp2_session_callbacks *callbacks = NULL;

    nghttp2_option *options = NULL;

    apr_allocator_t *allocator;

    apr_thread_mutex_t *mutex;

    uint32_t n;

    apr_pool_t *pool = NULL;

    h2_session *session;

    apr_status_t status;

    int rv;

    *psession = NULL;

    status = apr_allocator_create(&allocator);

    if (status != APR_SUCCESS) {

        return status;

    }

    apr_allocator_max_free_set(allocator, ap_max_mem_free);

    apr_pool_create_ex(&pool, c->pool, NULL, allocator);

    if (!pool) {

        apr_allocator_destroy(allocator);

        return APR_ENOMEM;

    }

    apr_pool_tag(pool, "h2_session");

    apr_allocator_owner_set(allocator, pool);

    status = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, pool);

    if (status != APR_SUCCESS) {

        apr_pool_destroy(pool);

        return APR_ENOMEM;

    }

    apr_allocator_mutex_set(allocator, mutex);

    session = apr_pcalloc(pool, sizeof(h2_session));

    if (!session) {

        return APR_ENOMEM;

    }

    *psession = session;

    session->id = c->id;

    session->c = c;

    session->r = r;

    session->s = h2_ctx_server_get(ctx);

    session->pool = pool;

    session->config = h2_config_sget(session->s);

    session->workers = workers;

    session->state = H2_SESSION_ST_INIT;

    session->local.accepting = 1;

    session->remote.accepting = 1;

    session->max_stream_count = h2_config_geti(session->config, 

                                               H2_CONF_MAX_STREAMS);

    session->max_stream_mem = h2_config_geti(session->config, 

                                             H2_CONF_STREAM_MAX_MEM);

    status = apr_thread_cond_create(&session->iowait, session->pool);

    if (status != APR_SUCCESS) {

        apr_pool_destroy(pool);

        return status;

    }

    session->in_pending = h2_iq_create(session->pool, (int)session->max_stream_count);

    if (session->in_pending == NULL) {

        apr_pool_destroy(pool);

        return APR_ENOMEM;

    }

    session->in_process = h2_iq_create(session->pool, (int)session->max_stream_count);

    if (session->in_process == NULL) {

        apr_pool_destroy(pool);

        return APR_ENOMEM;

    }

    session->monitor = apr_pcalloc(pool, sizeof(h2_stream_monitor));

    if (session->monitor == NULL) {

        apr_pool_destroy(pool);

        return APR_ENOMEM;

    }

    session->monitor->ctx = session;

    session->monitor->on_state_enter = on_stream_state_enter;

    session->monitor->on_state_event = on_stream_state_event;

    session->monitor->on_event = on_stream_event;

    session->mplx = h2_mplx_create(c, session->pool, session->config, 

                                   workers);

    /* connection input filter that feeds the session */

    session->cin = h2_filter_cin_create(session);

    ap_add_input_filter("H2_IN", session->cin, r, c);

    h2_conn_io_init(&session->io, c, session->config);

    session->bbtmp = apr_brigade_create(session->pool, c->bucket_alloc);

    status = init_callbacks(c, &callbacks);

    if (status != APR_SUCCESS) {

        ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c, APLOGNO(02927) 

                      "nghttp2: error in init_callbacks");

        apr_pool_destroy(pool);

        return status;