自学教程：C++ AP_DEBUG_ASSERT函数代码示例

/* Start submitting the response to a stream request. This is possible * once we have all the response headers. The response body will be * read by the session using the callback we supply. */apr_status_t h2_session_handle_response(h2_session *session, h2_stream *stream){    apr_status_t status = APR_SUCCESS;    int rv = 0;    AP_DEBUG_ASSERT(session);    AP_DEBUG_ASSERT(stream);    AP_DEBUG_ASSERT(stream->response);        if (stream->response->ngheader) {        rv = submit_response(session, stream->response);    }    else {        rv = nghttp2_submit_rst_stream(session->ngh2, NGHTTP2_FLAG_NONE,                                       stream->id, NGHTTP2_PROTOCOL_ERROR);    }        if (nghttp2_is_fatal(rv)) {        status = APR_EGENERAL;        h2_session_abort_int(session, rv);        ap_log_cerror(APLOG_MARK, APLOG_ERR, status, session->c,                      APLOGNO(02940) "submit_response: %s",                       nghttp2_strerror(rv));    }    return status;}

/** * Push a new socket onto the queue. * * precondition: ap_queue_info_wait_for_idler has already been called *               to reserve an idle worker thread */apr_status_t ap_queue_push(fd_queue_t *queue, apr_socket_t *sd, apr_pool_t *p){    fd_queue_elem_t *elem;    apr_status_t rv;    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {        return rv;    }    AP_DEBUG_ASSERT(!queue->terminated);    AP_DEBUG_ASSERT(!ap_queue_full(queue));    elem = &queue->data[queue->in];    queue->in++;    if (queue->in >= queue->bounds)        queue->in -= queue->bounds;    elem->sd = sd;    elem->p = p;    queue->nelts++;    apr_thread_cond_signal(queue->not_empty);    if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {        return rv;    }    return APR_SUCCESS;}

apr_status_t h2_request_rwrite(h2_request *req, request_rec *r){    apr_status_t status;        req->config    = h2_config_rget(r);    req->method    = r->method;    req->scheme    = (r->parsed_uri.scheme? r->parsed_uri.scheme                      : ap_http_scheme(r));    req->authority = r->hostname;    req->path      = apr_uri_unparse(r->pool, &r->parsed_uri,                                      APR_URI_UNP_OMITSITEPART);    if (!ap_strchr_c(req->authority, ':') && r->server && r->server->port) {        apr_port_t defport = apr_uri_port_of_scheme(req->scheme);        if (defport != r->server->port) {            /* port info missing and port is not default for scheme: append */            req->authority = apr_psprintf(r->pool, "%s:%d", req->authority,                                          (int)r->server->port);        }    }        AP_DEBUG_ASSERT(req->scheme);    AP_DEBUG_ASSERT(req->authority);    AP_DEBUG_ASSERT(req->path);    AP_DEBUG_ASSERT(req->method);    status = add_all_h1_header(req, r->pool, r->headers_in);    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, status, r,                  "h2_request(%d): rwrite %s host=%s://%s%s",                  req->id, req->method, req->scheme, req->authority, req->path);                      return status;}

void procmgr_init_spawn_cmd(fcgid_command * command, request_rec * r,                            fcgid_cmd_conf *cmd_conf){    fcgid_server_conf *sconf =        ap_get_module_config(r->server->module_config, &fcgid_module);    /* no truncation should ever occur */    AP_DEBUG_ASSERT(sizeof command->cgipath > strlen(cmd_conf->cgipath));    apr_cpystrn(command->cgipath, cmd_conf->cgipath, sizeof command->cgipath);    AP_DEBUG_ASSERT(sizeof command->cmdline > strlen(cmd_conf->cmdline));    apr_cpystrn(command->cmdline, cmd_conf->cmdline, sizeof command->cmdline);    command->inode = (apr_ino_t) -1;    command->deviceid = (dev_t) -1;    command->uid = (uid_t) - 1;    command->gid = (gid_t) - 1;    command->userdir = 0;    command->vhost_id = sconf->vhost_id;    if (r->server->server_hostname) {        apr_cpystrn(command->server_hostname, r->server->server_hostname,                    sizeof command->server_hostname);    }    else {        command->server_hostname[0] = '/0';    }    get_cmd_options(r, command->cgipath, &command->cmdopts, &command->cmdenv);}

void h2_io_set_response(h2_io *io, h2_response *response) {    AP_DEBUG_ASSERT(response);    AP_DEBUG_ASSERT(!io->response);    io->response = h2_response_copy(io->pool, response);    if (response->rst_error) {        h2_io_rst(io, response->rst_error);    }}

h2_stream *h2_mplx_next_submit(h2_mplx *m, h2_stream_set *streams){    apr_status_t status;    h2_stream *stream = NULL;    AP_DEBUG_ASSERT(m);    if (m->aborted) {        return NULL;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        h2_io *io = h2_io_set_pop_highest_prio(m->ready_ios);        if (io) {            stream = h2_stream_set_get(streams, io->id);            if (stream) {                if (io->rst_error) {                    h2_stream_rst(stream, io->rst_error);                }                else {                    AP_DEBUG_ASSERT(io->response);                    H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_next_submit_pre");                    h2_stream_set_response(stream, io->response, io->bbout);                    H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_next_submit_post");                }                            }            else {                /* We have the io ready, but the stream has gone away, maybe                 * reset by the client. Should no longer happen since such                 * streams should clear io's from the ready queue.                 */                ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, m->c, APLOGNO(02953)                               "h2_mplx(%ld): stream for response %d closed, "                              "resetting io to close request processing",                              m->id, io->id);                io->orphaned = 1;                if (io->task_done) {                    io_destroy(m, io, 1);                }                else {                    /* hang around until the h2_task is done, but                     * shutdown input and send out any events (e.g. window                     * updates) asap. */                    h2_io_in_shutdown(io);                    h2_io_rst(io, H2_ERR_STREAM_CLOSED);                    io_process_events(m, io);                }            }                        if (io->output_drained) {                apr_thread_cond_signal(io->output_drained);            }        }        apr_thread_mutex_unlock(m->lock);    }    return stream;}

apr_status_t h2_stream_write_data(h2_stream *stream,                                  const char *data, size_t len){    AP_DEBUG_ASSERT(stream);    AP_DEBUG_ASSERT(stream);    switch (stream->state) {        case H2_STREAM_ST_OPEN:            break;        default:            return APR_EINVAL;    }    return h2_request_write_data(stream->request, data, len);}

h2_stream *h2_mplx_next_submit(h2_mplx *m, h2_stream_set *streams){    apr_status_t status;    h2_stream *stream = NULL;    int acquired;    AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        h2_io *io = h2_io_set_pop_highest_prio(m->ready_ios);        if (io && !m->aborted) {            stream = h2_stream_set_get(streams, io->id);            if (stream) {                if (io->rst_error) {                    h2_stream_rst(stream, io->rst_error);                }                else {                    AP_DEBUG_ASSERT(io->response);                    H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_next_submit_pre");                    h2_stream_set_response(stream, io->response, io->bbout);                    H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_next_submit_post");                }            }            else {                /* We have the io ready, but the stream has gone away, maybe                 * reset by the client. Should no longer happen since such                 * streams should clear io's from the ready queue.                 */                ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, m->c,                                "h2_mplx(%ld): stream for response %d closed, "                              "resetting io to close request processing",                              m->id, io->id);                h2_io_make_orphaned(io, H2_ERR_STREAM_CLOSED);                if (!io->worker_started || io->worker_done) {                    io_destroy(m, io, 1);                }                else {                    /* hang around until the h2_task is done, but                     * shutdown input and send out any events (e.g. window                     * updates) asap. */                    h2_io_in_shutdown(io);                    io_process_events(m, io);                }            }                        h2_io_signal(io, H2_IO_WRITE);        }        leave_mutex(m, acquired);    }    return stream;}

apr_status_t h2_stream_schedule(h2_stream *stream, int eos,                                h2_stream_pri_cmp *cmp, void *ctx){    apr_status_t status;    AP_DEBUG_ASSERT(stream);    AP_DEBUG_ASSERT(stream->session);    AP_DEBUG_ASSERT(stream->session->mplx);        if (!output_open(stream)) {        return APR_ECONNRESET;    }    if (stream->scheduled) {        return APR_EINVAL;    }    if (eos) {        close_input(stream);    }        /* Seeing the end-of-headers, we have everything we need to      * start processing it.     */    status = h2_request_end_headers(stream->request, stream->pool, eos);    if (status == APR_SUCCESS) {        if (!eos) {            stream->bbin = apr_brigade_create(stream->pool,                                               stream->session->c->bucket_alloc);        }        stream->input_remaining = stream->request->content_length;                status = h2_mplx_process(stream->session->mplx, stream->id,                                  stream->request, eos, cmp, ctx);        stream->scheduled = 1;                ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, stream->session->c,                      "h2_stream(%ld-%d): scheduled %s %s://%s%s",                      stream->session->id, stream->id,                      stream->request->method, stream->request->scheme,                      stream->request->authority, stream->request->path);    }    else {        h2_stream_rst(stream, H2_ERR_INTERNAL_ERROR);        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, stream->session->c,                      "h2_stream(%ld-%d): RST=2 (internal err) %s %s://%s%s",                      stream->session->id, stream->id,                      stream->request->method, stream->request->scheme,                      stream->request->authority, stream->request->path);    }        return status;}

/* h2_io_on_read_cb implementation that offers the data read * directly to the session for consumption. */static apr_status_t session_receive(const char *data, apr_size_t len,                                    apr_size_t *readlen, int *done,                                    void *puser){    h2_session *session = (h2_session *)puser;    AP_DEBUG_ASSERT(session);    if (len > 0) {        ssize_t n = nghttp2_session_mem_recv(session->ngh2,                                             (const uint8_t *)data, len);        if (n < 0) {            ap_log_cerror(APLOG_MARK, APLOG_DEBUG, APR_EGENERAL,                          session->c,                          "h2_session: nghttp2_session_mem_recv error %d",                          (int)n);            if (nghttp2_is_fatal((int)n)) {                *done = 1;                h2_session_abort_int(session, (int)n);                return APR_EGENERAL;            }        }        else {            *readlen = n;        }    }    return APR_SUCCESS;}

apr_status_t h2_stream_write_eoh(h2_stream *stream, int eos){    apr_status_t status;    AP_DEBUG_ASSERT(stream);        /* Seeing the end-of-headers, we have everything we need to      * start processing it.     */    status = h2_mplx_create_task(stream->m, stream);    status = h2_mplx_create_task(stream->m, stream);    if (status == APR_SUCCESS) {        status = h2_request_end_headers(stream->request,                                         stream->m, stream->task, eos);        if (status == APR_SUCCESS) {            status = h2_mplx_do_task(stream->m, stream->task);        }        if (eos) {            status = h2_stream_write_eos(stream);        }        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, stream->m->c,                      "h2_mplx(%ld-%d): start stream, task %s %s (%s)",                      stream->m->id, stream->id,                      stream->request->method, stream->request->path,                      stream->request->authority);            }    return status;}

static h2_ctx *h2_ctx_create(conn_rec *c){    h2_ctx *ctx = apr_pcalloc(c->pool, sizeof(h2_ctx));    AP_DEBUG_ASSERT(ctx);    ap_set_module_config(c->conn_config, &h2_module, ctx);    return ctx;}

apr_status_t h2_mplx_out_trywait(h2_mplx *m, apr_interval_time_t timeout,                                 apr_thread_cond_t *iowait){    apr_status_t status;    int acquired;        AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        if (m->aborted) {            status = APR_ECONNABORTED;        }        else {            m->added_output = iowait;            status = apr_thread_cond_timedwait(m->added_output, m->lock, timeout);            if (APLOGctrace2(m->c)) {                ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, m->c,                              "h2_mplx(%ld): trywait on data for %f ms)",                              m->id, timeout/1000.0);            }            m->added_output = NULL;        }        leave_mutex(m, acquired);    }    return status;}

apr_status_t h2_mplx_out_write(h2_mplx *m, int stream_id,                                ap_filter_t* f, apr_bucket_brigade *bb,                               apr_table_t *trailers,                               struct apr_thread_cond_t *iowait){    apr_status_t status;    int acquired;        AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->orphaned) {            status = out_write(m, io, f, bb, trailers, iowait);            ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, m->c,                          "h2_mplx(%ld-%d): write with trailers=%s",                           m->id, io->id, trailers? "yes" : "no");            H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_write");                        have_out_data_for(m, stream_id);        }        else {            status = APR_ECONNABORTED;        }        leave_mutex(m, acquired);    }    return status;}

apr_status_t h2_mplx_out_read_to(h2_mplx *m, int stream_id,                                  apr_bucket_brigade *bb,                                  apr_off_t *plen, int *peos,                                 apr_table_t **ptrailers){    apr_status_t status;    int acquired;    AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->orphaned) {            H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_read_to_pre");                        status = h2_io_out_read_to(io, bb, plen, peos);                        H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_read_to_post");            if (status == APR_SUCCESS) {                h2_io_signal(io, H2_IO_WRITE);            }        }        else {            status = APR_ECONNABORTED;        }        *ptrailers = (*peos && io->response)? io->response->trailers : NULL;        leave_mutex(m, acquired);    }    return status;}

apr_status_t h2_mplx_stream_done(h2_mplx *m, int stream_id, int rst_error){    apr_status_t status = APR_SUCCESS;    apr_thread_mutex_t *holding;    int acquired;        /* This maybe called from inside callbacks that already hold the lock.     * E.g. when we are streaming out DATA and the EOF triggers the stream     * release.     */    AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        /* there should be an h2_io, once the stream has been scheduled         * for processing, e.g. when we received all HEADERs. But when         * a stream is cancelled very early, it will not exist. */        if (io) {            io_stream_done(m, io, rst_error);        }        leave_mutex(m, acquired);    }    return status;}

apr_status_t h2_mplx_out_read_to(h2_mplx *m, int stream_id,                                  apr_bucket_brigade *bb,                                  apr_off_t *plen, int *peos,                                 apr_table_t **ptrailers){    apr_status_t status;    AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->orphaned) {            H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_read_to_pre");                        status = h2_io_out_read_to(io, bb, plen, peos);                        H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_read_to_post");            if (status == APR_SUCCESS && io->output_drained) {                apr_thread_cond_signal(io->output_drained);            }        }        else {            status = APR_ECONNABORTED;        }        *ptrailers = (*peos && io->response)? io->response->trailers : NULL;        apr_thread_mutex_unlock(m->lock);    }    return status;}

apr_status_t h2_mplx_in_close(h2_mplx *m, int stream_id){    apr_status_t status;    AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->orphaned) {            status = h2_io_in_close(io);            H2_MPLX_IO_IN(APLOG_TRACE2, m, io, "h2_mplx_in_close");            if (io->input_arrived) {                apr_thread_cond_signal(io->input_arrived);            }            io_process_events(m, io);        }        else {            status = APR_ECONNABORTED;        }        apr_thread_mutex_unlock(m->lock);    }    return status;}

apr_status_t h2_mplx_in_read(h2_mplx *m, apr_read_type_e block,                             int stream_id, apr_bucket_brigade *bb,                             struct apr_thread_cond_t *iowait){    apr_status_t status;     AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->orphaned) {            io->input_arrived = iowait;            H2_MPLX_IO_IN(APLOG_TRACE2, m, io, "h2_mplx_in_read_pre");            status = h2_io_in_read(io, bb, -1);            while (APR_STATUS_IS_EAGAIN(status)                    && !is_aborted(m, &status)                   && block == APR_BLOCK_READ) {                apr_thread_cond_wait(io->input_arrived, m->lock);                status = h2_io_in_read(io, bb, -1);            }            H2_MPLX_IO_IN(APLOG_TRACE2, m, io, "h2_mplx_in_read_post");            io->input_arrived = NULL;        }        else {            status = APR_EOF;        }        apr_thread_mutex_unlock(m->lock);    }    return status;}

static void set_state(h2_stream *stream, h2_stream_state_t state){    AP_DEBUG_ASSERT(stream);    if (stream->state != state) {        stream->state = state;    }}

apr_status_t h2_mplx_in_update_windows(h2_mplx *m){    apr_status_t status;    int acquired;        AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        update_ctx ctx;                ctx.m               = m;        ctx.streams_updated = 0;        status = APR_EAGAIN;        h2_io_set_iter(m->stream_ios, update_window, &ctx);                if (ctx.streams_updated) {            status = APR_SUCCESS;        }        leave_mutex(m, acquired);    }    return status;}

apr_status_t h2_mplx_out_rst(h2_mplx *m, int stream_id, int error){    apr_status_t status;    AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        if (!m->aborted) {            h2_io *io = h2_io_set_get(m->stream_ios, stream_id);            if (io && !io->rst_error && !io->orphaned) {                h2_io_rst(io, error);                if (!io->response) {                        h2_io_set_add(m->ready_ios, io);                }                H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_rst");                                have_out_data_for(m, stream_id);                if (io->output_drained) {                    apr_thread_cond_signal(io->output_drained);                }            }            else {                status = APR_ECONNABORTED;            }        }        apr_thread_mutex_unlock(m->lock);    }    return status;}

apr_status_t h2_mplx_process(h2_mplx *m, int stream_id,                             const h2_request *req, int eos,                              h2_stream_pri_cmp *cmp, void *ctx){    apr_status_t status;        AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        h2_io *io = open_io(m, stream_id);        io->request = req;        io->request_body = !eos;        if (eos) {            status = h2_io_in_close(io);        }                h2_tq_add(m->q, io->id, cmp, ctx);        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, m->c,                      "h2_mplx(%ld-%d): process", m->c->id, stream_id);        H2_MPLX_IO_IN(APLOG_TRACE2, m, io, "h2_mplx_process");        apr_thread_mutex_unlock(m->lock);    }        if (status == APR_SUCCESS) {        workers_register(m);    }    return status;}

apr_status_t h2_mplx_out_rst(h2_mplx *m, int stream_id, int error){    apr_status_t status;    int acquired;        AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);        if (io && !io->rst_error && !io->orphaned) {            h2_io_rst(io, error);            if (!io->response) {                h2_io_set_add(m->ready_ios, io);            }            H2_MPLX_IO_OUT(APLOG_TRACE2, m, io, "h2_mplx_out_rst");                        have_out_data_for(m, stream_id);            h2_io_signal(io, H2_IO_WRITE);        }        else {            status = APR_ECONNABORTED;        }        leave_mutex(m, acquired);    }    return status;}

apr_status_t ap_queue_info_set_idle(fd_queue_info_t * queue_info,                                    apr_pool_t * pool_to_recycle){    apr_status_t rv;    apr_int32_t prev_idlers;    ap_push_pool(queue_info, pool_to_recycle);    /* Atomically increment the count of idle workers */    prev_idlers = apr_atomic_inc32(&(queue_info->idlers)) - zero_pt;    /* If other threads are waiting on a worker, wake one up */    if (prev_idlers < 0) {        rv = apr_thread_mutex_lock(queue_info->idlers_mutex);        if (rv != APR_SUCCESS) {            AP_DEBUG_ASSERT(0);            return rv;        }        rv = apr_thread_cond_signal(queue_info->wait_for_idler);        if (rv != APR_SUCCESS) {            apr_thread_mutex_unlock(queue_info->idlers_mutex);            return rv;        }        rv = apr_thread_mutex_unlock(queue_info->idlers_mutex);        if (rv != APR_SUCCESS) {            return rv;        }    }    return APR_SUCCESS;}

apr_status_t h2_mplx_process(h2_mplx *m, int stream_id, const h2_request *req,                              h2_stream_pri_cmp *cmp, void *ctx){    apr_status_t status;    int was_empty = 0;    int acquired;        AP_DEBUG_ASSERT(m);    if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {        if (m->aborted) {            status = APR_ECONNABORTED;        }        else {            h2_io *io = open_io(m, stream_id);            io->request = req;                        if (!io->request->body) {                status = h2_io_in_close(io);            }                        was_empty = h2_tq_empty(m->q);            h2_tq_add(m->q, io->id, cmp, ctx);                        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, m->c,                          "h2_mplx(%ld-%d): process", m->c->id, stream_id);            H2_MPLX_IO_IN(APLOG_TRACE2, m, io, "h2_mplx_process");        }        leave_mutex(m, acquired);    }    if (status == APR_SUCCESS && was_empty) {        workers_register(m);    }    return status;}

void h2_session_destroy(h2_session *session){    AP_DEBUG_ASSERT(session);    if (session->mplx) {        h2_mplx_release_and_join(session->mplx, session->iowait);        session->mplx = NULL;    }    if (session->streams) {        if (h2_stream_set_size(session->streams)) {            ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,                          "h2_session(%ld): destroy, %d streams open",                          session->id, (int)h2_stream_set_size(session->streams));        }        h2_stream_set_destroy(session->streams);        session->streams = NULL;    }    if (session->ngh2) {        nghttp2_session_del(session->ngh2);        session->ngh2 = NULL;    }    h2_conn_io_destroy(&session->io);        if (session->iowait) {        apr_thread_cond_destroy(session->iowait);        session->iowait = NULL;    }        if (session->pool) {        apr_pool_destroy(session->pool);    }}

apr_status_t h2_mplx_out_write(h2_mplx *m, int stream_id,                                ap_filter_t* f, apr_bucket_brigade *bb,                               struct apr_thread_cond_t *iowait){    apr_status_t status;    AP_DEBUG_ASSERT(m);    if (m->aborted) {        return APR_ECONNABORTED;    }    status = apr_thread_mutex_lock(m->lock);    if (APR_SUCCESS == status) {        if (!m->aborted) {            h2_io *io = h2_io_set_get(m->stream_ios, stream_id);            if (io) {                status = out_write(m, io, f, bb, iowait);                have_out_data_for(m, stream_id);                if (m->aborted) {                    return APR_ECONNABORTED;                }            }            else {                status = APR_ECONNABORTED;            }        }                if (m->lock) {            apr_thread_mutex_unlock(m->lock);        }    }    return status;}

apr_status_t h2_stream_rwrite(h2_stream *stream, request_rec *r){    AP_DEBUG_ASSERT(stream);    set_state(stream, H2_STREAM_ST_OPEN);    apr_status_t status = h2_request_rwrite(stream->request, r, stream->m);    return status;}