int h2_h2_stream_pre_conn(conn_rec* c, void *arg)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
if (ctx && h2_ctx_is_task(c)) {
/* This connection is a pseudo-connection used for a h2_task.
* Since we read/write directly from it ourselves, we need
* to disable a possible ssl connection filter.
*/
if (opt_ssl_engine_disable) {
opt_ssl_engine_disable(c);
}
}
return OK;
}
static int h2_protocol_switch(conn_rec *c, request_rec *r, server_rec *s,
const char *protocol)
{
int found = 0;
const char **protos = h2_h2_is_tls(c)? h2_tls_protos : h2_clear_protos;
const char **p = protos;
(void)s;
while (*p) {
if (!strcmp(*p, protocol)) {
found = 1;
break;
}
p++;
}
if (found) {
h2_ctx *ctx = h2_ctx_get(c);
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c,
"switching protocol to '%s'", protocol);
h2_ctx_protocol_set(ctx, protocol);
h2_ctx_server_set(ctx, s);
if (r != NULL) {
apr_status_t status;
/* Switching in the middle of a request means that
* we have to send out the response to this one in h2
* format. So we need to take over the connection
* right away.
*/
ap_remove_input_filter_byhandle(r->input_filters, "http_in");
ap_remove_input_filter_byhandle(r->input_filters, "reqtimeout");
ap_remove_output_filter_byhandle(r->output_filters, "HTTP_HEADER");
/* Ok, start an h2_conn on this one. */
status = h2_conn_process(r->connection, r, r->server);
if (status != DONE) {
/* Nothing really to do about this. */
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, status, r,
"session proessed, unexpected status");
}
}
return DONE;
}
return DECLINED;
}
static int h2_task_process_conn(conn_rec* c)
{
h2_ctx *ctx = h2_ctx_get(c);
if (h2_ctx_is_task(ctx)) {
if (!ctx->task_env->serialize_headers) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, processing request directly");
h2_task_process_request(ctx->task_env);
return DONE;
}
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_task(%s), serialized handling", ctx->task_env->id);
}
return DECLINED;
}
int h2_h2_cleanup_conn(conn_rec* c)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
if (ctx) {
if (h2_ctx_is_task(c)) {
/* cleanup on task connections */
ap_remove_input_filter_byhandle(c->input_filters, "reqtimeout");
}
else if (!h2_ctx_is_negotiated(c)) {
/* cleanup on master h2 connections */
ap_remove_input_filter_byhandle(c->input_filters, "reqtimeout");
}
}
return DECLINED;
}
static int h2_h2_pre_close_conn(conn_rec *c)
{
h2_ctx *ctx;
/* slave connection? */
if (c->master) {
return DECLINED;
}
ctx = h2_ctx_get(c, 0);
if (ctx) {
/* If the session has been closed correctly already, we will not
* find a h2_ctx here. The presence indicates that the session
* is still ongoing. */
return h2_conn_pre_close(ctx, c);
}
return DECLINED;
}
static int h2_task_pre_conn(conn_rec* c, void *arg)
{
h2_ctx *ctx;
if (!c->master) {
return OK;
}
ctx = h2_ctx_get(c, 0);
(void)arg;
if (h2_ctx_is_task(ctx)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, pre_connection, found stream task");
ap_add_input_filter("H2_SLAVE_IN", NULL, NULL, c);
ap_add_output_filter("H2_PARSE_H1", NULL, NULL, c);
ap_add_output_filter("H2_SLAVE_OUT", NULL, NULL, c);
}
return OK;
}
static int h2_task_pre_conn(conn_rec* c, void *arg)
{
h2_ctx *ctx = h2_ctx_get(c);
(void)arg;
if (h2_ctx_is_task(ctx)) {
h2_task *task = h2_ctx_get_task(ctx);
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, pre_connection, found stream task");
/* Add our own, network level in- and output filters.
*/
ap_add_input_filter("H2_TO_H1", task, NULL, c);
ap_add_output_filter("H1_TO_H2", task, NULL, c);
}
return OK;
}
apr_status_t h2_conn_setup(conn_rec *c, request_rec *r, server_rec *s)
{
h2_session *session;
h2_ctx *ctx;
apr_status_t status;
if (!workers) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02911)
"workers not initialized");
return APR_EGENERAL;
}
if (APR_SUCCESS == (status = h2_session_create(&session, c, r, s, workers))) {
ctx = h2_ctx_get(c, 1);
h2_ctx_session_set(ctx, session);
}
return status;
}
static int h2_task_pre_conn(conn_rec* c, void *arg)
{
(void)arg;
h2_ctx *ctx = h2_ctx_get(c);
if (h2_ctx_is_task(ctx)) {
h2_task_env *env = h2_ctx_get_task(ctx);
/* This connection is a pseudo-connection used for a h2_task.
* Since we read/write directly from it ourselves, we need
* to disable a possible ssl connection filter.
*/
h2_tls_disable(c);
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, pre_connection, found stream task");
/* Add our own, network level in- and output filters.
*/
ap_add_input_filter("H2_TO_H1", env, NULL, c);
ap_add_output_filter("H1_TO_H2", env, NULL, c);
}
return OK;
}
h2_ctx *h2_ctx_rget(const request_rec *r)
{
return h2_ctx_get(r->connection);
}
int h2_ctx_is_active(conn_rec * c)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
return ctx && ctx->protocol != NULL;
}
int h2_ctx_is_negotiated( conn_rec * c )
{
h2_ctx *ctx = h2_ctx_get(c, 0);
return ctx && ctx->is_negotiated;
}
int h2_ctx_is_task(conn_rec * c)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
return ctx && !!ctx->task;
}
int h2_ctx_is_session(conn_rec * c)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
return ctx && !ctx->task;
}
const char *h2_ctx_get_protocol(conn_rec* c)
{
h2_ctx *ctx = h2_ctx_get(c, 0);
return ctx? ctx->protocol : NULL;
}
int h2_h2_process_conn(conn_rec* c)
{
apr_status_t status;
h2_ctx *ctx;
if (c->master) {
return DECLINED;
}
ctx = h2_ctx_get(c, 0);
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "h2_h2, process_conn");
if (h2_ctx_is_task(ctx)) {
/* our stream pseudo connection */
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c, "h2_h2, task, declined");
return DECLINED;
}
if (!ctx && c->keepalives == 0) {
const char *proto = ap_get_protocol(c);
if (APLOGctrace1(c)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "h2_h2, process_conn, "
"new connection using protocol '%s', direct=%d, "
"tls acceptable=%d", proto, h2_allows_h2_direct(c),
h2_is_acceptable_connection(c, 1));
}
if (!strcmp(AP_PROTOCOL_HTTP1, proto)
&& h2_allows_h2_direct(c)
&& h2_is_acceptable_connection(c, 1)) {
/* Fresh connection still is on http/1.1 and H2Direct is enabled.
* Otherwise connection is in a fully acceptable state.
* -> peek at the first 24 incoming bytes
*/
apr_bucket_brigade *temp;
char *s = NULL;
apr_size_t slen;
temp = apr_brigade_create(c->pool, c->bucket_alloc);
status = ap_get_brigade(c->input_filters, temp,
AP_MODE_SPECULATIVE, APR_BLOCK_READ, 24);
if (status != APR_SUCCESS) {
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, c, APLOGNO(03054)
"h2_h2, error reading 24 bytes speculative");
apr_brigade_destroy(temp);
return DECLINED;
}
apr_brigade_pflatten(temp, &s, &slen, c->pool);
if ((slen >= 24) && !memcmp(H2_MAGIC_TOKEN, s, 24)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c,
"h2_h2, direct mode detected");
if (!ctx) {
ctx = h2_ctx_get(c, 1);
}
h2_ctx_protocol_set(ctx, h2_h2_is_tls(c)? "h2" : "h2c");
}
else {
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, not detected in %d bytes: %s",
(int)slen, s);
}
apr_brigade_destroy(temp);
}
}
if (ctx) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "process_conn");
if (!h2_ctx_session_get(ctx)) {
status = h2_conn_setup(ctx, c, NULL);
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, c, "conn_setup");
if (status != APR_SUCCESS) {
h2_ctx_clear(c);
return status;
}
}
return h2_conn_run(ctx, c);
}
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "h2_h2, declined");
return DECLINED;
}
int h2_h2_process_conn(conn_rec* c)
{
h2_ctx *ctx = h2_ctx_get(c);
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "h2_h2, process_conn");
if (h2_ctx_is_task(ctx)) {
/* our stream pseudo connection */
return DECLINED;
}
if (h2_ctx_protocol_get(c)) {
/* Something has been negotiated */
}
else if (!strcmp(AP_PROTOCOL_HTTP1, ap_get_protocol(c))
&& h2_allows_h2_direct(c)
&& h2_is_acceptable_connection(c, 1)) {
/* connection still is on http/1.1 and H2Direct is enabled.
* Otherwise connection is in a fully acceptable state.
* -> peek at the first 24 incoming bytes
*/
apr_bucket_brigade *temp;
apr_status_t status;
char *s = NULL;
apr_size_t slen;
temp = apr_brigade_create(c->pool, c->bucket_alloc);
status = ap_get_brigade(c->input_filters, temp,
AP_MODE_SPECULATIVE, APR_BLOCK_READ, 24);
if (status != APR_SUCCESS) {
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, c,
"h2_h2, error reading 24 bytes speculative");
apr_brigade_destroy(temp);
return DECLINED;
}
apr_brigade_pflatten(temp, &s, &slen, c->pool);
if ((slen >= 24) && !memcmp(H2_MAGIC_TOKEN, s, 24)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c,
"h2_h2, direct mode detected");
h2_ctx_protocol_set(ctx, h2_h2_is_tls(c)? "h2" : "h2c");
}
else {
ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, c,
"h2_h2, not detected in %d bytes: %s",
(int)slen, s);
}
apr_brigade_destroy(temp);
}
else {
/* the connection is not HTTP/1.1 or not for us, don't touch it */
return DECLINED;
}
/* If "h2" was selected as protocol (by whatever mechanism), take over
* the connection.
*/
if (h2_ctx_is_active(ctx)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c,
"h2_h2, connection, h2 active");
return h2_conn_process(c, NULL, ctx->server);
}
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, c, "h2_h2, declined");
return DECLINED;
}
