-*- coding: utf-8 -*-
Changes with Apache 2.5.0
+ *) mod_http2: connection how keep a "push diary" where hashes of already
+ pushed resources are kept. See directive H2PushDiarySize for managing this.
+ Push diaries can be initialized by clients via the "Cache-Digest" request
+ header. This carries a base64url encoded. compressed Golomb set as described
+ in https://datatracker.ietf.org/doc/draft-kazuho-h2-cache-digest/
+ Introduced a status handler for HTTP/2 connections, giving various counters
+ and statistics about the current connection, plus its cache digest value
+ in a JSON record. Not a replacement for more HTTP/2 in the server status.
+ Configured as
+ <Location "/http2-status">
+ SetHandler http2-status
+ </Location>
+ [Stefan Eissing]
+
*) mod_rewrite: Avoid looping on relative substitutions that
result in the same filename we started with. PR 58854.
[Eric Covener]
<name>H2PushDiarySize</name>
<description>H2 Server Push Diary Size</description>
<syntax>H2PushDiarySize n</syntax>
- <default>H2PushDiarySize 128</default>
+ <default>H2PushDiarySize 256</default>
<contextlist>
<context>server config</context>
<context>virtual host</context>
section to influence the number for all connections to that virtual host.
</p>
<p>
- The push diary records a digest (currently using SHA256) of pushed
+ The push diary records a digest (currently using a 64 bit number) of pushed
resources (their URL) to avoid duplicate pushes on the same connection.
These value are not persisted, so clients openeing a new connection
will experience known pushes again. There is ongoing work to enable
</p>
<p>
If the maximum size is reached, newer entries replace the oldest
- ones. Using SHA256, each diary entry uses 32 bytes, letting a
- default diary with 128 entries consume around 4 KB of memory.
+ ones. A diary entry uses 8 bytes, letting a
+ default diary with 256 entries consume around 2 KB of memory.
</p>
<p>
A size of 0 will effectively disable the push diary.
handling. Implemented by mod_http2. This module requires a libnghttp2 installation.
See --with-nghttp2 on how to manage non-standard locations. This module
is usually linked shared and requires loading. ], $http2_objs, , most, [
+ APACHE_CHECK_OPENSSL
+ if test "$ac_cv_openssl" = "yes" ; then
+ APR_ADDTO(MOD_CPPFLAGS, ["-DH2_OPENSSL"])
+ fi
+
APACHE_CHECK_NGHTTP2
if test "$ac_cv_nghttp2" = "yes" ; then
if test "x$enable_http2" = "xshared"; then
-1, /* connection timeout */
-1, /* keepalive timeout */
0, /* stream timeout */
- 128, /* push diary size */
+ 256, /* push diary size */
};
#include "h2_worker.h"
#include "h2_workers.h"
#include "h2_conn.h"
+#include "h2_version.h"
static struct h2_workers *workers;
apr_size_t write_size;
apr_time_t last_write;
+ apr_int64_t bytes_read;
apr_int64_t bytes_written;
int buffer_output;
#include "h2_private.h"
#include "h2_conn_io.h"
+#include "h2_ctx.h"
+#include "h2_mplx.h"
+#include "h2_push.h"
+#include "h2_task.h"
+#include "h2_stream.h"
+#include "h2_stream_set.h"
+#include "h2_response.h"
+#include "h2_session.h"
#include "h2_util.h"
+#include "h2_version.h"
#include "h2_filter.h"
}
return status;
}
+
+/*******************************************************************************
+ * http2 connection status handler + stream out source
+ ******************************************************************************/
+
+static const char *H2_SOS_H2_STATUS = "http2-status";
+
+int h2_filter_h2_status_handler(request_rec *r)
+{
+ h2_ctx *ctx = h2_ctx_rget(r);
+ h2_task *task;
+
+ if (strcmp(r->handler, "http2-status")) {
+ return DECLINED;
+ }
+ if (r->method_number != M_GET) {
+ return DECLINED;
+ }
+
+ task = ctx? h2_ctx_get_task(ctx) : NULL;
+ if (task) {
+ /* We need to handle the actual output on the main thread, as
+ * we need to access h2_session information. */
+ apr_table_setn(r->notes, H2_RESP_SOS_NOTE, H2_SOS_H2_STATUS);
+ apr_table_setn(r->headers_out, "Content-Type", "application/json");
+ r->status = 200;
+ return DONE;
+ }
+ return DECLINED;
+}
+
+#define bbout(...) apr_brigade_printf(bb, NULL, NULL, __VA_ARGS__)
+static apr_status_t h2_sos_h2_status_buffer(h2_sos *sos, apr_bucket_brigade *bb)
+{
+ h2_stream *stream = sos->stream;
+ h2_session *session = stream->session;
+ h2_mplx *mplx = session->mplx;
+ apr_status_t status;
+
+ if (!bb) {
+ bb = apr_brigade_create(stream->pool, session->c->bucket_alloc);
+ }
+
+ bbout("{\n");
+ bbout(" \"HTTP2\": \"on\",\n");
+ bbout(" \"H2PUSH\": \"%s\",\n", h2_session_push_enabled(session)? "on" : "off");
+ bbout(" \"mod_http2_version\": \"%s\",\n", MOD_HTTP2_VERSION);
+ bbout(" \"session_id\": %ld,\n", (long)session->id);
+ bbout(" \"streams_max\": %d,\n", (int)session->max_stream_count);
+ bbout(" \"this_stream\": %d,\n", stream->id);
+ bbout(" \"streams_open\": %d,\n", (int)h2_stream_set_size(session->streams));
+ bbout(" \"max_stream_started\": %d,\n", mplx->max_stream_started);
+ bbout(" \"requests_received\": %d,\n", session->requests_received);
+ bbout(" \"responses_submitted\": %d,\n", session->responses_submitted);
+ bbout(" \"streams_reset\": %d, \n", session->streams_reset);
+ bbout(" \"pushes_promised\": %d,\n", session->pushes_promised);
+ bbout(" \"pushes_submitted\": %d,\n", session->pushes_submitted);
+ bbout(" \"pushes_reset\": %d,\n", session->pushes_reset);
+
+ if (session->push_diary) {
+ const char *data;
+ const char *base64_digest;
+ apr_size_t len;
+
+ status = h2_push_diary_digest_get(session->push_diary, stream->pool, 1024, &data, &len);
+ if (status == APR_SUCCESS) {
+ base64_digest = h2_util_base64url_encode(data, len, stream->pool);
+ bbout(" \"cache_digest\": \"%s\",\n", base64_digest);
+ }
+
+ /* try the reverse for testing purposes */
+ status = h2_push_diary_digest_set(session->push_diary, data, len);
+ if (status == APR_SUCCESS) {
+ status = h2_push_diary_digest_get(session->push_diary, stream->pool, 1024, &data, &len);
+ if (status == APR_SUCCESS) {
+ base64_digest = h2_util_base64url_encode(data, len, stream->pool);
+ bbout(" \"cache_digest^2\": \"%s\",\n", base64_digest);
+ }
+ }
+ }
+ bbout(" \"frames_received\": %ld,\n", (long)session->frames_received);
+ bbout(" \"frames_sent\": %ld,\n", (long)session->frames_sent);
+ bbout(" \"bytes_received\": %"APR_UINT64_T_FMT",\n", session->io.bytes_read);
+ bbout(" \"bytes_sent\": %"APR_UINT64_T_FMT"\n", session->io.bytes_written);
+ bbout("}\n");
+
+ return sos->prev->buffer(sos->prev, bb);
+}
+
+static apr_status_t h2_sos_h2_status_read_to(h2_sos *sos, apr_bucket_brigade *bb,
+ apr_off_t *plen, int *peos)
+{
+ return sos->prev->read_to(sos->prev, bb, plen, peos);
+}
+
+static apr_status_t h2_sos_h2_status_prep_read(h2_sos *sos, apr_off_t *plen, int *peos)
+{
+ return sos->prev->prep_read(sos->prev, plen, peos);
+}
+
+static apr_status_t h2_sos_h2_status_readx(h2_sos *sos, h2_io_data_cb *cb, void *ctx,
+ apr_off_t *plen, int *peos)
+{
+ return sos->prev->readx(sos->prev, cb, ctx, plen, peos);
+}
+
+static apr_table_t *h2_sos_h2_status_get_trailers(h2_sos *sos)
+{
+ return sos->prev->get_trailers(sos->prev);
+}
+
+static h2_sos *h2_sos_h2_status_create(h2_sos *prev)
+{
+ h2_sos *sos;
+ h2_response *response = prev->response;
+
+ apr_table_unset(response->headers, "Content-Length");
+ response->content_length = -1;
+
+ sos = apr_pcalloc(prev->stream->pool, sizeof(*sos));
+ sos->prev = prev;
+ sos->response = response;
+ sos->stream = prev->stream;
+ sos->buffer = h2_sos_h2_status_buffer;
+ sos->prep_read = h2_sos_h2_status_prep_read;
+ sos->readx = h2_sos_h2_status_readx;
+ sos->read_to = h2_sos_h2_status_read_to;
+ sos->get_trailers = h2_sos_h2_status_get_trailers;
+
+ return sos;
+}
+
+h2_sos *h2_filter_sos_create(const char *name, struct h2_sos *prev)
+{
+ if (!strcmp(H2_SOS_H2_STATUS, name)) {
+ return h2_sos_h2_status_create(prev);
+ }
+ return prev;
+}
+
#ifndef __mod_h2__h2_filter__
#define __mod_h2__h2_filter__
+struct h2_stream;
struct h2_session;
typedef apr_status_t h2_filter_cin_cb(void *ctx,
apr_read_type_e block,
apr_off_t readbytes);
+typedef struct h2_sos h2_sos;
+typedef apr_status_t h2_sos_data_cb(void *ctx, const char *data, apr_off_t len);
+
+typedef apr_status_t h2_sos_buffer(h2_sos *sos, apr_bucket_brigade *bb);
+typedef apr_status_t h2_sos_prep_read(h2_sos *sos, apr_off_t *plen, int *peos);
+typedef apr_status_t h2_sos_readx(h2_sos *sos, h2_sos_data_cb *cb,
+ void *ctx, apr_off_t *plen, int *peos);
+typedef apr_status_t h2_sos_read_to(h2_sos *sos, apr_bucket_brigade *bb,
+ apr_off_t *plen, int *peos);
+typedef apr_table_t *h2_sos_get_trailers(h2_sos *sos);
+
+
+#define H2_RESP_SOS_NOTE "h2-sos-filter"
+
+struct h2_sos {
+ struct h2_stream *stream;
+ h2_sos *prev;
+ struct h2_response *response;
+ void *ctx;
+ h2_sos_buffer *buffer;
+ h2_sos_prep_read *prep_read;
+ h2_sos_readx *readx;
+ h2_sos_read_to *read_to;
+ h2_sos_get_trailers *get_trailers;
+};
+
+h2_sos *h2_filter_sos_create(const char *name, struct h2_sos *prev);
+
+int h2_filter_h2_status_handler(request_rec *r);
+
#endif /* __mod_h2__h2_filter__ */
static apr_status_t make_h2_headers(h2_from_h1 *from_h1, request_rec *r)
{
from_h1->response = h2_response_create(from_h1->stream_id, 0,
- from_h1->http_status, from_h1->hlines,
+ from_h1->http_status,
+ from_h1->hlines,
+ r->notes,
from_h1->pool);
from_h1->content_length = from_h1->response->content_length;
from_h1->chunked = r->chunked;
#include <apr_hash.h>
#include <apr_time.h>
+#ifdef H2_OPENSSL
+#include <openssl/sha.h>
+#endif
+
#include <httpd.h>
#include <http_core.h>
#include <http_log.h>
* push diary
******************************************************************************/
-struct h2_push_digest {
- union {
- uint32_t hash;
- } val;
-};
-
typedef struct h2_push_diary_entry {
- h2_push_digest digest;
+ apr_uint64_t hash;
} h2_push_diary_entry;
-static uint32_t val_apr_hash(const char *str)
+#ifdef H2_OPENSSL
+static void sha256_update(SHA256_CTX *ctx, const char *s)
+{
+ SHA256_Update(ctx, s, strlen(s));
+}
+
+static void calc_sha256_hash(h2_push_diary *diary, apr_uint64_t *phash, h2_push *push)
+{
+ SHA256_CTX sha256;
+ union {
+ unsigned char hash[SHA256_DIGEST_LENGTH];
+ apr_uint64_t val;
+ } ctx;
+
+ SHA256_Init(&sha256);
+ sha256_update(&sha256, push->req->scheme);
+ sha256_update(&sha256, "://");
+ sha256_update(&sha256, push->req->authority);
+ sha256_update(&sha256, push->req->path);
+ SHA256_Final(ctx.hash, &sha256);
+
+ *phash = ctx.val;
+}
+#endif
+
+static unsigned int val_apr_hash(const char *str)
{
apr_ssize_t len = strlen(str);
return apr_hashfunc_default(str, &len);
}
-static void calc_apr_hash(h2_push_diary *diary, h2_push_digest *d, h2_push *push)
+static void calc_apr_hash(h2_push_diary *diary, apr_uint64_t *phash, h2_push *push)
{
- unsigned int val;
-
+ apr_uint64_t val;
+#if APR_UINT64MAX > APR_UINT_MAX
+ val = (val_apr_hash(push->req->scheme) << 32);
+ val ^= (val_apr_hash(push->req->authority) << 16);
+ val ^= val_apr_hash(push->req->path);
+#else
val = val_apr_hash(push->req->scheme);
val ^= val_apr_hash(push->req->authority);
val ^= val_apr_hash(push->req->path);
-
- d->val.hash = val % (diary->N * diary->P);
-}
-
-static int cmp_hash(h2_push_digest *d1, h2_push_digest *d2)
-{
- return (d1->val.hash > d2->val.hash)? 1 : ((d1->val.hash == d2->val.hash)? 0 : -1);
+#endif
+ *phash = val;
}
-static uint32_t ceil_power_of_2(uint32_t n)
+static apr_int32_t ceil_power_of_2(apr_int32_t n)
{
--n;
n |= n >> 1;
return ++n;
}
-h2_push_diary *h2_push_diary_create(apr_pool_t *p, uint32_t N, uint32_t P)
+static h2_push_diary *diary_create(apr_pool_t *p, h2_push_digest_type dtype,
+ apr_size_t N)
{
h2_push_diary *diary = NULL;
if (N > 0) {
diary = apr_pcalloc(p, sizeof(*diary));
- diary->N = ceil_power_of_2(N);
- diary->P = ceil_power_of_2(P? P : ((1<<31)/diary->N));
- diary->entries = apr_array_make(p, 16, sizeof(void*));
- diary->dtype = H2_PUSH_DIGEST_APR_HASH;
- diary->dcalc = calc_apr_hash;
- diary->dcmp = cmp_hash;
+ diary->NMax = ceil_power_of_2(N);
+ diary->N = diary->NMax;
+ /* the mask we use in value comparision depends on where we got
+ * the values from. If we calculate them ourselves, we can use
+ * the full 64 bits.
+ * If we set the diary via a compressed golomb set, we have less
+ * relevant bits and need to use a smaller mask. */
+ diary->mask = 0xffffffffffffffffu;
+ /* grows by doubling, start with a power of 2 */
+ diary->entries = apr_array_make(p, 16, sizeof(h2_push_diary_entry));
+
+ switch (dtype) {
+#ifdef H2_OPENSSL
+ case H2_PUSH_DIGEST_SHA256:
+ diary->dtype = H2_PUSH_DIGEST_SHA256;
+ diary->dcalc = calc_sha256_hash;
+ break;
+#endif /* ifdef H2_OPENSSL */
+ default:
+ diary->dtype = H2_PUSH_DIGEST_APR_HASH;
+ diary->dcalc = calc_apr_hash;
+ break;
+ }
}
return diary;
}
-static int h2_push_diary_find(h2_push_diary *diary, h2_push_digest *d)
+h2_push_diary *h2_push_diary_create(apr_pool_t *p, apr_size_t N)
+{
+ return diary_create(p, H2_PUSH_DIGEST_SHA256, N);
+}
+
+static int h2_push_diary_find(h2_push_diary *diary, apr_uint64_t hash)
{
if (diary) {
h2_push_diary_entry *e;
int i;
+
/* search from the end, where the last accessed digests are */
+ hash &= diary->mask;
for (i = diary->entries->nelts-1; i >= 0; --i) {
- e = APR_ARRAY_IDX(diary->entries, i, h2_push_diary_entry*);
- if (!diary->dcmp(&e->digest, d)) {
+ e = &APR_ARRAY_IDX(diary->entries, i, h2_push_diary_entry);
+ if (e->hash == hash) {
return i;
}
}
static h2_push_diary_entry *move_to_last(h2_push_diary *diary, apr_size_t idx)
{
- h2_push_diary_entry **entries = (h2_push_diary_entry**)diary->entries->elts;
- h2_push_diary_entry *e = entries[idx];
+ h2_push_diary_entry *entries = (h2_push_diary_entry*)diary->entries->elts;
+ h2_push_diary_entry e;
+ apr_size_t lastidx = diary->entries->nelts-1;
+
/* move entry[idx] to the end */
- if (idx < (diary->entries->nelts-1)) {
- memmove(entries+idx, entries+idx+1, sizeof(h2_push_diary_entry *) * diary->entries->nelts-idx-1);
- entries[diary->entries->nelts-1] = e;
+ if (idx < lastidx) {
+ e = entries[idx];
+ memmove(entries+idx, entries+idx+1, sizeof(e) * (lastidx - idx));
+ entries[lastidx] = e;
}
- return e;
+ return &entries[lastidx];
}
-static h2_push_diary_entry *h2_push_diary_append(h2_push_diary *diary, h2_push_digest *digest)
+static void h2_push_diary_append(h2_push_diary *diary, h2_push_diary_entry *e)
{
- h2_push_diary_entry *e;
+ h2_push_diary_entry *ne;
if (diary->entries->nelts < diary->N) {
/* append a new diary entry at the end */
- e = apr_pcalloc(diary->entries->pool, sizeof(*e));
- APR_ARRAY_PUSH(diary->entries, h2_push_diary_entry*) = e;
+ APR_ARRAY_PUSH(diary->entries, h2_push_diary_entry) = *e;
+ ne = &APR_ARRAY_IDX(diary->entries, diary->entries->nelts-1, h2_push_diary_entry);
}
else {
- e = move_to_last(diary, 0);
+ /* replace content with new digest. keeps memory usage constant once diary is full */
+ ne = move_to_last(diary, 0);
+ *ne = *e;
}
- /* replace content with new digest. keeps memory usage constant once diary is full */
- memcpy(&e->digest, digest, sizeof(*digest));
- return e;
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, diary->entries->pool,
+ "push_diary_append: masking %lx", ne->hash);
+ ne->hash &= diary->mask;
}
apr_array_header_t *h2_push_diary_update(h2_session *session, apr_array_header_t *pushes)
{
apr_array_header_t *npushes = pushes;
- h2_push_digest d;
+ h2_push_diary_entry e;
int i, idx;
if (session->push_diary && pushes) {
h2_push *push;
push = APR_ARRAY_IDX(pushes, i, h2_push*);
- session->push_diary->dcalc(session->push_diary, &d, push);
- idx = h2_push_diary_find(session->push_diary, &d);
+ session->push_diary->dcalc(session->push_diary, &e.hash, push);
+ idx = h2_push_diary_find(session->push_diary, e.hash);
if (idx >= 0) {
- ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, session->c,
"push_diary_update: already there PUSH %s", push->req->path);
move_to_last(session->push_diary, idx);
}
else {
- ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, session->c,
"push_diary_update: adding PUSH %s", push->req->path);
if (!npushes) {
npushes = apr_array_make(pushes->pool, 5, sizeof(h2_push_diary_entry*));
}
APR_ARRAY_PUSH(npushes, h2_push*) = push;
- h2_push_diary_append(session->push_diary, &d);
+ h2_push_diary_append(session->push_diary, &e);
}
}
}
const struct h2_request *req,
const struct h2_response *res)
{
- apr_array_header_t *pushes = h2_push_collect(stream->pool, req, res);
+ h2_session *session = stream->session;
+ const char *cache_digest = apr_table_get(req->headers, "Cache-Digest");
+ apr_array_header_t *pushes;
+ apr_status_t status;
+
+ if (cache_digest && session->push_diary) {
+ status = h2_push_diary_digest64_set(session->push_diary, cache_digest, stream->pool);
+ if (status != APR_SUCCESS) {
+ ap_log_cerror(APLOG_MARK, APLOG_DEBUG, status, session->c,
+ "h2_session(%ld): push diary set from Cache-Digest: %s",
+ session->id, cache_digest);
+ }
+ }
+ pushes = h2_push_collect(stream->pool, req, res);
return h2_push_diary_update(stream->session, pushes);
}
+/* log2(n) iff n is a power of 2 */
+static unsigned char log2(apr_uint32_t n)
+{
+ int lz = 0;
+ if (!n) {
+ return 0;
+ }
+ if (!(n & 0xffff0000u)) {
+ lz += 16;
+ n = (n << 16);
+ }
+ if (!(n & 0xff000000u)) {
+ lz += 8;
+ n = (n << 8);
+ }
+ if (!(n & 0xf0000000u)) {
+ lz += 4;
+ n = (n << 4);
+ }
+ if (!(n & 0xc0000000u)) {
+ lz += 2;
+ n = (n << 2);
+ }
+ if (!(n & 0x80000000u)) {
+ lz += 1;
+ }
+
+ return 31 - lz;
+}
+
+/* log2(n) iff n is a power of 2 */
+static unsigned char log2_64(apr_uint64_t n)
+{
+ apr_uint32_t i = (n & 0xffffffffu);
+ if (i) {
+ return log2(i);
+ }
+ return log2((apr_uint32_t)(n >> 32)) + 32;
+}
+
+static apr_int32_t log2inv(unsigned char log2)
+{
+ return log2? (1 << log2) : 1;
+}
+
+
+typedef struct {
+ h2_push_diary *diary;
+ unsigned char log2p;
+ apr_uint32_t mask_bits;
+ apr_uint64_t mask;
+ apr_uint32_t fixed_bits;
+ apr_uint64_t fixed_mask;
+ apr_pool_t *pool;
+ unsigned char *data;
+ apr_size_t datalen;
+ apr_size_t offset;
+ unsigned int bit;
+ apr_uint64_t last;
+} gset_encoder;
+
+static int cmp_puint64(const void *p1, const void *p2)
+{
+ const apr_uint64_t *pu1 = p1, *pu2 = p2;
+ return (*pu1 > *pu2)? 1 : ((*pu1 == *pu2)? 0 : -1);
+}
+
+/* in golomb bit stream encoding, bit 0 is the 8th of the first char, or
+ * more generally:
+ * char(bit/8) & cbit_mask[(bit % 8)]
+ */
+static unsigned char cbit_mask[] = {
+ 0x80u,
+ 0x40u,
+ 0x20u,
+ 0x10u,
+ 0x08u,
+ 0x04u,
+ 0x02u,
+ 0x01u,
+};
+
+static apr_status_t gset_encode_bit(gset_encoder *encoder, int bit)
+{
+ if (++encoder->bit >= 8) {
+ if (++encoder->offset >= encoder->datalen) {
+ apr_size_t nlen = encoder->datalen*2;
+ unsigned char *ndata = apr_pcalloc(encoder->pool, nlen);
+ if (!ndata) {
+ return APR_ENOMEM;
+ }
+ memcpy(ndata, encoder->data, encoder->datalen);
+ encoder->data = ndata;
+ encoder->datalen = nlen;
+ }
+ encoder->bit = 0;
+ encoder->data[encoder->offset] = 0xffu;
+ }
+ if (!bit) {
+ encoder->data[encoder->offset] &= ~cbit_mask[encoder->bit];
+ }
+ return APR_SUCCESS;
+}
+
+static apr_status_t gset_encode_next(gset_encoder *encoder, apr_uint64_t pval)
+{
+ apr_uint64_t delta, flex_bits;
+ apr_status_t status = APR_SUCCESS;
+ int i;
+
+ delta = pval - encoder->last;
+ encoder->last = pval;
+ flex_bits = (delta >> encoder->fixed_bits);
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, encoder->pool,
+ "h2_push_diary_enc: val=%lx, delta=%lx flex_bits=%ld, "
+ "fixed_bits=%d, fixed_val=%lx",
+ pval, delta, flex_bits, encoder->fixed_bits, delta&encoder->fixed_mask);
+ for (; flex_bits != 0; --flex_bits) {
+ status = gset_encode_bit(encoder, 1);
+ if (status != APR_SUCCESS) {
+ return status;
+ }
+ }
+ status = gset_encode_bit(encoder, 0);
+ if (status != APR_SUCCESS) {
+ return status;
+ }
+
+ for (i = encoder->fixed_bits-1; i >= 0; --i) {
+ status = gset_encode_bit(encoder, (delta >> i) & 1);
+ if (status != APR_SUCCESS) {
+ return status;
+ }
+ }
+ return APR_SUCCESS;
+}
+
+/**
+ * Get a cache digest as described in
+ * https://datatracker.ietf.org/doc/draft-kazuho-h2-cache-digest/
+ * from the contents of the push diary.
+ *
+ * @param diary the diary to calculdate the digest from
+ * @param p the pool to use
+ * @param pdata on successful return, the binary cache digest
+ * @param plen on successful return, the length of the binary data
+ */
+apr_status_t h2_push_diary_digest_get(h2_push_diary *diary, apr_pool_t *pool,
+ apr_uint32_t maxP,
+ const char **pdata, apr_size_t *plen)
+{
+ apr_size_t nelts, N, i;
+ unsigned char log2n, log2pmax, mask_bits;
+ gset_encoder encoder;
+ apr_uint64_t *hashes;
+ apr_size_t hash_count;
+
+ nelts = diary->entries->nelts;
+
+ if (nelts > APR_UINT32_MAX) {
+ /* should not happen */
+ return APR_ENOTIMPL;
+ }
+ N = ceil_power_of_2(nelts);
+ log2n = log2(N);
+
+ mask_bits = log2_64(diary->mask + 1);
+ if (mask_bits <= log2n) {
+ /* uhm, what? */
+ return APR_ENOTIMPL;
+ }
+
+ /* Now log2p is the max number of relevant bits, so that
+ * log2p + log2n == mask_bits. We can uise a lower log2p
+ * and have a shorter set encoding...
+ */
+ log2pmax = log2(ceil_power_of_2(maxP));
+
+ memset(&encoder, 0, sizeof(encoder));
+ encoder.diary = diary;
+ encoder.log2p = H2MIN(mask_bits - log2n, log2pmax);
+ encoder.mask_bits = log2n + encoder.log2p;
+ encoder.mask = 1;
+ encoder.mask = (encoder.mask << encoder.mask_bits) - 1;
+ encoder.fixed_bits = encoder.log2p;
+ encoder.fixed_mask = 1;
+ encoder.fixed_mask = (encoder.fixed_mask << encoder.fixed_bits) - 1;
+ encoder.pool = pool;
+ encoder.datalen = 512;
+ encoder.data = apr_pcalloc(encoder.pool, encoder.datalen);
+
+ encoder.data[0] = log2n;
+ encoder.data[1] = encoder.log2p;
+ encoder.offset = 1;
+ encoder.bit = 8;
+ encoder.last = 0;
+
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, pool,
+ "h2_push_diary_digest_get: %d entries, N=%d, log2n=%d, "
+ "mask_bits=%d, enc.mask_bits=%d, enc.log2p=%d",
+ (int)nelts, (int)N, (int)log2n, (int)mask_bits,
+ (int)encoder.mask_bits, (int)encoder.log2p);
+
+ hash_count = diary->entries->nelts;
+ hashes = apr_pcalloc(encoder.pool, hash_count);
+ for (i = 0; i < hash_count; ++i) {
+ hashes[i] = ((&APR_ARRAY_IDX(diary->entries, i, h2_push_diary_entry))->hash
+ & encoder.mask);
+ }
+
+ qsort(hashes, hash_count, sizeof(apr_uint64_t), cmp_puint64);
+ for (i = 0; i < hash_count; ++i) {
+ if (!i || (hashes[i] != hashes[i-1])) {
+ gset_encode_next(&encoder, hashes[i]);
+ }
+ }
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, pool,
+ "h2_push_diary_digest_get: golomb compressed hashes, %d bytes",
+ (int)encoder.offset + 1);
+
+ *pdata = (const char *)encoder.data;
+ *plen = encoder.offset + 1;
+
+ return APR_SUCCESS;
+}
+
+typedef struct {
+ h2_push_diary *diary;
+ apr_pool_t *pool;
+ unsigned char log2p;
+ const unsigned char *data;
+ apr_size_t datalen;
+ apr_size_t offset;
+ unsigned int bit;
+ apr_uint64_t last_val;
+} gset_decoder;
+
+static int gset_decode_next_bit(gset_decoder *decoder)
+{
+ if (++decoder->bit >= 8) {
+ if (++decoder->offset >= decoder->datalen) {
+ return -1;
+ }
+ decoder->bit = 0;
+ }
+ return (decoder->data[decoder->offset] & cbit_mask[decoder->bit])? 1 : 0;
+}
+
+static apr_status_t gset_decode_next(gset_decoder *decoder, apr_uint64_t *phash)
+{
+ apr_uint64_t flex = 0, fixed = 0, delta;
+ int i;
+
+ /* read 1 bits until we encounter 0, then read log2n(diary-P) bits.
+ * On a malformed bit-string, this will not fail, but produce results
+ * which are pbly too large. Luckily, the diary will modulo the hash.
+ */
+ while (1) {
+ int bit = gset_decode_next_bit(decoder);
+ if (bit == -1) {
+ return APR_EINVAL;
+ }
+ if (!bit) {
+ break;
+ }
+ ++flex;
+ }
+
+ for (i = 0; i < decoder->log2p; ++i) {
+ int bit = gset_decode_next_bit(decoder);
+ if (bit == -1) {
+ return APR_EINVAL;
+ }
+ fixed = (fixed << 1) | bit;
+ }
+
+ delta = (flex << decoder->log2p) | fixed;
+ *phash = delta + decoder->last_val;
+ decoder->last_val = *phash;
+
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, decoder->pool,
+ "h2_push_diary_digest_dec: val=%lx, delta=%lx, flex=%d, fixed=%lx",
+ *phash, delta, (int)flex, fixed);
+
+ return APR_SUCCESS;
+}
+
+/**
+ * Initialize the push diary by a cache digest as described in
+ * https://datatracker.ietf.org/doc/draft-kazuho-h2-cache-digest/
+ * .
+ * @param diary the diary to set the digest into
+ * @param data the binary cache digest
+ * @param len the length of the cache digest
+ * @return APR_EINVAL if digest was not successfully parsed
+ */
+apr_status_t h2_push_diary_digest_set(h2_push_diary *diary,
+ const char *data, apr_size_t len)
+{
+ gset_decoder decoder;
+ unsigned char log2n, log2p;
+ apr_size_t N, i;
+ apr_pool_t *pool = diary->entries->pool;
+ h2_push_diary_entry e;
+ apr_status_t status = APR_SUCCESS;
+ apr_uint64_t mask;
+ int mask_bits;
+
+ if (len < 2) {
+ /* at least this should be there */
+ return APR_EINVAL;
+ }
+ log2n = data[0];
+ log2p = data[1];
+ mask_bits = log2n + log2p;
+ if (mask_bits > 64) {
+ /* cannot handle */
+ return APR_ENOTIMPL;
+ }
+ else if (mask_bits == 64) {
+ mask = 0xffffffffffffffffu;
+ }
+ else {
+ mask = 1;
+ mask = (mask << mask_bits) - 1;
+ }
+
+ /* whatever is in the digest, it replaces the diary entries */
+ apr_array_clear(diary->entries);
+
+ N = log2inv(log2n + log2p);
+
+ decoder.diary = diary;
+ decoder.pool = pool;
+ decoder.log2p = log2p;
+ decoder.data = (const unsigned char*)data;
+ decoder.datalen = len;
+ decoder.offset = 1;
+ decoder.bit = 8;
+ decoder.last_val = 0;
+
+ diary->N = N;
+ diary->mask = mask;
+ /* Determine effective N we use for storage */
+ if (!N) {
+ /* a totally empty cache digest. someone tells us that she has no
+ * entries in the cache at all. Use our own preferences for N+mask
+ */
+ diary->N = diary->NMax;
+ diary->mask = 0xffffffffffffffffu;
+ return APR_SUCCESS;
+ }
+ else if (N > diary->NMax) {
+ /* Store not more than diary is configured to hold. We open us up
+ * to DOS attacks otherwise. */
+ diary->N = diary->NMax;
+ }
+
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, pool,
+ "h2_push_diary_digest_set: N=%d, log2n=%d, "
+ "diary->mask=%lx, dec.log2p=%d",
+ (int)diary->N, (int)log2n, diary->mask,
+ (int)decoder.log2p);
+
+ for (i = 0; i < diary->N; ++i) {
+ if (gset_decode_next(&decoder, &e.hash) != APR_SUCCESS) {
+ /* the data may have less than N values */
+ break;
+ }
+ h2_push_diary_append(diary, &e);
+ }
+
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, pool,
+ "h2_push_diary_digest_set: diary now with %d entries, mask=%lx",
+ (int)diary->entries->nelts, diary->mask);
+ return status;
+}
+
+apr_status_t h2_push_diary_digest64_set(h2_push_diary *diary, const char *data64url,
+ apr_pool_t *pool)
+{
+ const char *data;
+ apr_size_t len = h2_util_base64url_decode(&data, data64url, pool);
+ ap_log_perror(APLOG_MARK, APLOG_TRACE1, 0, pool,
+ "h2_push_diary_digest64_set: digest=%s, dlen=%d",
+ data64url, (int)len);
+ return h2_push_diary_digest_set(diary, data, len);
+}
+
H2_PUSH_DIGEST_SHA256
} h2_push_digest_type;
-typedef struct h2_push_digest h2_push_digest;
typedef struct h2_push_diary h2_push_diary;
-typedef void h2_push_digest_calc(h2_push_diary *diary, h2_push_digest *d, h2_push *push);
-typedef int h2_push_digest_cmp(h2_push_digest *d1, h2_push_digest *d2);
+typedef void h2_push_digest_calc(h2_push_diary *diary, apr_uint64_t *phash, h2_push *push);
struct h2_push_diary {
apr_array_header_t *entries;
- uint32_t N; /* Max + of entries, power of 2 */
- uint32_t P; /* Probability 1/P of false positive, power of 2 */
+ apr_size_t NMax; /* Maximum for N, should size change be necessary */
+ apr_size_t N; /* Current maximum number of entries, power of 2 */
+ apr_uint64_t mask; /* applied on hash value comparision */
h2_push_digest_type dtype;
h2_push_digest_calc *dcalc;
- h2_push_digest_cmp *dcmp;
};
/**
*
* @oaram p the pool to use
* @param N the max number of entries, rounded up to 2^x
- * @param P false positives with 1/P probability, rounded up to 2^x, if 0
- * diary will itself choose the best value
* @return the created diary, might be NULL of max_entries is 0
*/
-h2_push_diary *h2_push_diary_create(apr_pool_t *p, uint32_t N, uint32_t P);
+h2_push_diary *h2_push_diary_create(apr_pool_t *p, apr_size_t N);
/**
* Filters the given pushes against the diary and returns only those pushes
apr_array_header_t *h2_push_collect_update(struct h2_stream *stream,
const struct h2_request *req,
const struct h2_response *res);
+/**
+ * Get a cache digest as described in
+ * https://datatracker.ietf.org/doc/draft-kazuho-h2-cache-digest/
+ * from the contents of the push diary.
+ *
+ * @param diary the diary to calculdate the digest from
+ * @param p the pool to use
+ * @param pdata on successful return, the binary cache digest
+ * @param plen on successful return, the length of the binary data
+ */
+apr_status_t h2_push_diary_digest_get(h2_push_diary *diary, apr_pool_t *p,
+ apr_uint32_t maxP, const char **pdata,
+ apr_size_t *plen);
+
+/**
+ * Initialize the push diary by a cache digest as described in
+ * https://datatracker.ietf.org/doc/draft-kazuho-h2-cache-digest/
+ * .
+ * @param diary the diary to set the digest into
+ * @param data the binary cache digest
+ * @param len the length of the cache digest
+ * @return APR_EINVAL if digest was not successfully parsed
+ */
+apr_status_t h2_push_diary_digest_set(h2_push_diary *diary,
+ const char *data, apr_size_t len);
+
+apr_status_t h2_push_diary_digest64_set(h2_push_diary *diary, const char *data64url,
+ apr_pool_t *pool);
#endif /* defined(__mod_h2__h2_push__) */
#include <nghttp2/nghttp2.h>
#include "h2_private.h"
+#include "h2_filter.h"
#include "h2_h2.h"
#include "h2_util.h"
#include "h2_request.h"
}
}
+static const char *get_sos_filter(apr_table_t *notes)
+{
+ return notes? apr_table_get(notes, H2_RESP_SOS_NOTE) : NULL;
+}
+
static h2_response *h2_response_create_int(int stream_id,
int rst_error,
int http_status,
apr_table_t *headers,
+ apr_table_t *notes,
apr_pool_t *pool)
{
h2_response *response;
return NULL;
}
- response->stream_id = stream_id;
- response->rst_error = rst_error;
- response->http_status = http_status? http_status : 500;
+ response->stream_id = stream_id;
+ response->rst_error = rst_error;
+ response->http_status = http_status? http_status : 500;
response->content_length = -1;
- response->headers = headers;
+ response->headers = headers;
+ response->sos_filter = get_sos_filter(notes);
s = apr_table_get(headers, "Content-Length");
if (s) {
int rst_error,
int http_status,
apr_array_header_t *hlines,
+ apr_table_t *notes,
apr_pool_t *pool)
{
return h2_response_create_int(stream_id, rst_error, http_status,
- parse_headers(hlines, pool), pool);
+ parse_headers(hlines, pool), notes, pool);
}
h2_response *h2_response_rcreate(int stream_id, request_rec *r,
return NULL;
}
- response->stream_id = stream_id;
- response->http_status = r->status;
+ response->stream_id = stream_id;
+ response->http_status = r->status;
response->content_length = -1;
- response->headers = header;
+ response->headers = header;
+ response->sos_filter = get_sos_filter(r->notes);
if (response->http_status == HTTP_FORBIDDEN) {
const char *cause = apr_table_get(r->notes, "ssl-renegotiate-forbidden");
apr_table_setn(headers, "Date", date);
apr_table_setn(headers, "Server", ap_get_server_banner());
- return h2_response_create_int(stream_id, 0, 500, headers, pool);
+ return h2_response_create_int(stream_id, 0, 500, headers, NULL, pool);
}
h2_response *h2_response_clone(apr_pool_t *pool, h2_response *from)
{
h2_response *to = apr_pcalloc(pool, sizeof(h2_response));
- to->stream_id = from->stream_id;
- to->http_status = from->http_status;
+
+ to->stream_id = from->stream_id;
+ to->http_status = from->http_status;
to->content_length = from->content_length;
+ to->sos_filter = from->sos_filter;
if (from->headers) {
- to->headers = apr_table_clone(pool, from->headers);
+ to->headers = apr_table_clone(pool, from->headers);
}
if (from->trailers) {
- to->trailers = apr_table_clone(pool, from->trailers);
+ to->trailers = apr_table_clone(pool, from->trailers);
}
return to;
}
struct h2_push;
typedef struct h2_response {
- int stream_id;
- int rst_error;
- int http_status;
- apr_off_t content_length;
+ int stream_id;
+ int rst_error;
+ int http_status;
+ apr_off_t content_length;
apr_table_t *headers;
apr_table_t *trailers;
+ const char *sos_filter;
} h2_response;
/**
int rst_error,
int http_status,
apr_array_header_t *hlines,
+ apr_table_t *notes,
apr_pool_t *pool);
/**
h2_stream_set_add(session->streams, stream);
if (H2_STREAM_CLIENT_INITIATED(stream_id)
&& stream_id > session->max_stream_received) {
+ ++session->requests_received;
session->max_stream_received = stream->id;
}
h2_stream *stream, int eos)
{
(void)session;
- ++session->requests_received;
return h2_stream_schedule(stream, eos, h2_session_push_enabled(session),
stream_pri_cmp, session);
}
h2_session *session = (h2_session *)userp;
(void)ngh2;
- if (APLOGctrace2(session->c)) {
+ if (APLOGcdebug(session->c)) {
char buffer[256];
frame_print(frame, buffer, sizeof(buffer)/sizeof(buffer[0]));
- ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c,
- "h2_session: callback on_invalid_frame_recv error=%d %s",
- error, buffer);
+ ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
+ "h2_session(%ld): recv unknown FRAME[%s], frames=%ld/%ld (r/s)",
+ session->id, buffer, (long)session->frames_received,
+ (long)session->frames_sent);
}
return 0;
}
"h2_session(%ld-%d): RST_STREAM by client, errror=%d",
session->id, (int)frame->hd.stream_id,
(int)frame->rst_stream.error_code);
- ++session->streams_reset;
+ stream = h2_session_get_stream(session, frame->hd.stream_id);
+ if (stream && stream->initiated_on) {
+ ++session->pushes_reset;
+ }
+ else {
+ ++session->streams_reset;
+ }
break;
case NGHTTP2_GOAWAY:
dispatch_event(session, H2_SESSION_EV_REMOTE_GOAWAY, 0, NULL);
}
n = h2_config_geti(session->config, H2_CONF_PUSH_DIARY_SIZE);
- session->push_diary = h2_push_diary_create(session->pool, n, 0);
+ session->push_diary = h2_push_diary_create(session->pool, n);
if (APLOGcdebug(c)) {
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c,
"session(%ld) created, timeout=%d, keepalive_timeout=%d, "
- "max_streams=%d, stream_mem=%d, push_diary(N=%d,P=%d)",
+ "max_streams=%d, stream_mem=%d, push_diary(type=%d,N=%d)",
session->id, session->timeout_secs, session->keepalive_secs,
(int)session->max_stream_count, (int)session->max_stream_mem,
- (int)session->push_diary->N, (int)session->push_diary->P);
+ session->push_diary->dtype,
+ (int)session->push_diary->N);
}
}
return session;
static apr_status_t submit_response(h2_session *session, h2_stream *stream)
{
apr_status_t status = APR_SUCCESS;
+ h2_response *response = h2_stream_get_response(stream);
int rv = 0;
AP_DEBUG_ASSERT(session);
AP_DEBUG_ASSERT(stream);
- AP_DEBUG_ASSERT(stream->response || stream->rst_error);
+ AP_DEBUG_ASSERT(response || stream->rst_error);
if (stream->submitted) {
rv = NGHTTP2_PROTOCOL_ERROR;
}
- else if (stream->response && stream->response->headers) {
+ else if (response && response->headers) {
nghttp2_data_provider provider;
- h2_response *response = stream->response;
h2_ngheader *ngh;
const h2_priority *prio;
response->headers);
rv = nghttp2_submit_response(session->ngh2, response->stream_id,
ngh->nv, ngh->nvlen, &provider);
- ++session->responses_sent;
}
else {
int err = H2_STREAM_RST(stream, H2_ERR_PROTOCOL_ERROR);
rv = nghttp2_submit_rst_stream(session->ngh2, NGHTTP2_FLAG_NONE,
stream->id, err);
- ++session->responses_sent;
}
stream->submitted = 1;
+ if (stream->initiated_on) {
+ ++session->pushes_submitted;
+ }
+ else {
+ ++session->responses_submitted;
+ }
if (nghttp2_is_fatal(rv)) {
status = APR_EGENERAL;
session->id, is->id, nghttp2_strerror(nid));
return NULL;
}
- ++session->streams_pushed;
+ ++session->pushes_promised;
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_stream(%ld-%d): SERVER_PUSH %d for %s %s on %d",
}
else {
*readlen = n;
+ session->io.bytes_read += n;
}
}
return APR_SUCCESS;
unsigned int eoc_written : 1; /* h2 eoc bucket written */
apr_interval_time_t wait_us; /* timout during BUSY_WAIT state, micro secs */
- int unsent_submits; /* number of submitted, but not yet sent
- responses. */
- int unsent_promises; /* number of submitted, but not yet sent
- * push promised */
-
- apr_size_t frames_received; /* number of http/2 frames received */
- apr_size_t frames_sent; /* number of http/2 frames sent */
+ int unsent_submits; /* number of submitted, but not yet written responses. */
+ int unsent_promises; /* number of submitted, but not yet written push promised */
+
int requests_received; /* number of http/2 requests received */
- int responses_sent; /* number of http/2 responses submitted */
+ int responses_submitted; /* number of http/2 responses submitted */
int streams_reset; /* number of http/2 streams reset by client */
- int streams_pushed; /* number of http/2 streams pushed */
+ int pushes_promised; /* number of http/2 push promises submitted */
+ int pushes_submitted; /* number of http/2 pushed responses submitted */
+ int pushes_reset; /* number of http/2 pushed reset by client */
+
+ apr_size_t frames_received; /* number of http/2 frames received */
+ apr_size_t frames_sent; /* number of http/2 frames sent */
+
int max_stream_received; /* highest stream id created */
int max_stream_handled; /* highest stream id completed */
#include "h2_conn.h"
#include "h2_config.h"
#include "h2_h2.h"
+#include "h2_filter.h"
#include "h2_mplx.h"
#include "h2_push.h"
#include "h2_request.h"
#include "h2_util.h"
-#define H2_STREAM_OUT(lvl,s,msg) \
- do { \
- if (APLOG_C_IS_LEVEL((s)->session->c,lvl)) \
- h2_util_bb_log((s)->session->c,(s)->id,lvl,msg,(s)->bbout); \
- } while(0)
#define H2_STREAM_IN(lvl,s,msg) \
do { \
if (APLOG_C_IS_LEVEL((s)->session->c,lvl)) \
}
}
+static h2_sos *h2_sos_mplx_create(h2_stream *stream, h2_response *response);
+
h2_stream *h2_stream_create(int id, apr_pool_t *pool, h2_session *session)
{
h2_stream *stream = apr_pcalloc(pool, sizeof(h2_stream));
h2_stream *stream = h2_stream_create(id, pool, session);
set_state(stream, H2_STREAM_ST_OPEN);
stream->request = h2_request_create(id, pool, session->config);
- stream->bbout = apr_brigade_create(stream->pool,
- stream->session->c->bucket_alloc);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_stream(%ld-%d): opened", session->id, stream->id);
stream->session->id, stream->id, error_code);
}
+struct h2_response *h2_stream_get_response(h2_stream *stream)
+{
+ return stream->sos? stream->sos->response : NULL;
+}
+
apr_status_t h2_stream_set_response(h2_stream *stream, h2_response *response,
apr_bucket_brigade *bb)
{
apr_status_t status = APR_SUCCESS;
+ h2_sos *sos;
+
if (!output_open(stream)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, stream->session->c,
"h2_stream(%ld-%d): output closed",
return APR_ECONNRESET;
}
- stream->response = response;
- if (bb && !APR_BRIGADE_EMPTY(bb)) {
- apr_size_t move_all = INT_MAX;
- /* we can move file handles from h2_mplx into this h2_stream as many
- * as we want, since the lifetimes are the same and we are not freeing
- * the ones in h2_mplx->io before this stream is done. */
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream set_response_pre");
- status = h2_util_move(stream->bbout, bb, 16 * 1024, &move_all,
- "h2_stream_set_response");
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream set_response_post");
+ sos = h2_sos_mplx_create(stream, response);
+ if (sos->response->sos_filter) {
+ sos = h2_filter_sos_create(sos->response->sos_filter, sos);
}
+ stream->sos = sos;
+ status = stream->sos->buffer(stream->sos, bb);
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
"h2_stream(%ld-%d): set_response(%d)",
- stream->session->id, stream->id, response->http_status);
+ stream->session->id, stream->id, stream->sos->response->http_status);
return status;
}
return status;
}
+void h2_stream_set_suspended(h2_stream *stream, int suspended)
+{
+ AP_DEBUG_ASSERT(stream);
+ stream->suspended = !!suspended;
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, stream->session->c,
+ "h2_stream(%ld-%d): suspended=%d",
+ stream->session->id, stream->id, stream->suspended);
+}
+
+int h2_stream_is_suspended(h2_stream *stream)
+{
+ AP_DEBUG_ASSERT(stream);
+ return stream->suspended;
+}
+
apr_status_t h2_stream_prep_read(h2_stream *stream,
apr_off_t *plen, int *peos)
{
- apr_status_t status = APR_SUCCESS;
- const char *src;
- apr_table_t *trailers = NULL;
- int test_read = (*plen == 0);
-
if (stream->rst_error) {
return APR_ECONNRESET;
}
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream prep_read_pre");
- if (!APR_BRIGADE_EMPTY(stream->bbout)) {
- src = "stream";
- status = h2_util_bb_avail(stream->bbout, plen, peos);
- if (!test_read && status == APR_SUCCESS && !*peos && !*plen) {
- apr_brigade_cleanup(stream->bbout);
- return h2_stream_prep_read(stream, plen, peos);
- }
- trailers = stream->response? stream->response->trailers : NULL;
+ if (!stream->sos) {
+ return APR_EGENERAL;
}
- else {
- src = "mplx";
- status = h2_mplx_out_readx(stream->session->mplx, stream->id,
- NULL, NULL, plen, peos, &trailers);
- if (trailers && stream->response) {
- h2_response_set_trailers(stream->response, trailers);
- }
- }
-
- if (!test_read && status == APR_SUCCESS && !*peos && !*plen) {
- status = APR_EAGAIN;
- }
-
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream prep_read_post");
- ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
- "h2_stream(%ld-%d): prep_read %s, len=%ld eos=%d, trailers=%s",
- stream->session->id, stream->id, src, (long)*plen, *peos,
- trailers? "yes" : "no");
- return status;
+ return stream->sos->prep_read(stream->sos, plen, peos);
}
apr_status_t h2_stream_readx(h2_stream *stream,
h2_io_data_cb *cb, void *ctx,
apr_off_t *plen, int *peos)
{
- apr_status_t status = APR_SUCCESS;
- apr_table_t *trailers = NULL;
- const char *src;
-
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream readx_pre");
if (stream->rst_error) {
return APR_ECONNRESET;
}
- *peos = 0;
- if (!APR_BRIGADE_EMPTY(stream->bbout)) {
- apr_off_t origlen = *plen;
-
- src = "stream";
- status = h2_util_bb_readx(stream->bbout, cb, ctx, plen, peos);
- if (status == APR_SUCCESS && !*peos && !*plen) {
- apr_brigade_cleanup(stream->bbout);
- *plen = origlen;
- return h2_stream_readx(stream, cb, ctx, plen, peos);
- }
- }
- else {
- src = "mplx";
- status = h2_mplx_out_readx(stream->session->mplx, stream->id,
- cb, ctx, plen, peos, &trailers);
- }
-
- if (trailers && stream->response) {
- ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
- "h2_stream(%ld-%d): readx, saving trailers",
- stream->session->id, stream->id);
- h2_response_set_trailers(stream->response, trailers);
- }
-
- if (status == APR_SUCCESS && !*peos && !*plen) {
- status = APR_EAGAIN;
+ if (!stream->sos) {
+ return APR_EGENERAL;
}
-
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream readx_post");
- ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
- "h2_stream(%ld-%d): readx %s, len=%ld eos=%d",
- stream->session->id, stream->id, src, (long)*plen, *peos);
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream readx_post");
-
- return status;
+ return stream->sos->readx(stream->sos, cb, ctx, plen, peos);
}
apr_status_t h2_stream_read_to(h2_stream *stream, apr_bucket_brigade *bb,
apr_off_t *plen, int *peos)
{
- apr_status_t status = APR_SUCCESS;
- apr_table_t *trailers = NULL;
-
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream read_to_pre");
if (stream->rst_error) {
return APR_ECONNRESET;
}
-
- if (APR_BRIGADE_EMPTY(stream->bbout)) {
- apr_off_t tlen = *plen;
- int eos;
- status = h2_mplx_out_read_to(stream->session->mplx, stream->id,
- stream->bbout, &tlen, &eos, &trailers);
- }
-
- if (status == APR_SUCCESS && !APR_BRIGADE_EMPTY(stream->bbout)) {
- status = h2_transfer_brigade(bb, stream->bbout, stream->pool,
- plen, peos);
+ if (!stream->sos) {
+ return APR_EGENERAL;
}
- else {
- *plen = 0;
- *peos = 0;
- }
-
- if (trailers && stream->response) {
- ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
- "h2_stream(%ld-%d): read_to, saving trailers",
- stream->session->id, stream->id);
- h2_response_set_trailers(stream->response, trailers);
- }
-
- if (status == APR_SUCCESS && !*peos && !*plen) {
- status = APR_EAGAIN;
- }
- H2_STREAM_OUT(APLOG_TRACE2, stream, "h2_stream read_to_post");
- ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, stream->session->c,
- "h2_stream(%ld-%d): read_to, len=%ld eos=%d",
- stream->session->id, stream->id, (long)*plen, *peos);
- return status;
-}
-
-void h2_stream_set_suspended(h2_stream *stream, int suspended)
-{
- AP_DEBUG_ASSERT(stream);
- stream->suspended = !!suspended;
- ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, stream->session->c,
- "h2_stream(%ld-%d): suspended=%d",
- stream->session->id, stream->id, stream->suspended);
-}
-
-int h2_stream_is_suspended(h2_stream *stream)
-{
- AP_DEBUG_ASSERT(stream);
- return stream->suspended;
+ return stream->sos->read_to(stream->sos, bb, plen, peos);
}
int h2_stream_input_is_open(h2_stream *stream)
apr_array_header_t *pushes;
int i;
- pushes = h2_push_collect_update(stream, stream->request, stream->response);
+ pushes = h2_push_collect_update(stream, stream->request,
+ h2_stream_get_response(stream));
if (pushes && !apr_is_empty_array(pushes)) {
ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, stream->session->c,
"h2_stream(%ld-%d): found %d push candidates",
apr_table_t *h2_stream_get_trailers(h2_stream *stream)
{
- return stream->response? stream->response->trailers : NULL;
+ return stream->sos? stream->sos->get_trailers(stream->sos) : NULL;
}
const h2_priority *h2_stream_get_priority(h2_stream *stream)
{
- if (stream->initiated_on && stream->response) {
- const char *ctype = apr_table_get(stream->response->headers, "content-type");
+ h2_response *response = h2_stream_get_response(stream);
+
+ if (stream->initiated_on && response) {
+ const char *ctype = apr_table_get(response->headers, "content-type");
if (ctype) {
/* FIXME: Not good enough, config needs to come from request->server */
return h2_config_get_priority(stream->session->config, ctype);
return NULL;
}
+/*******************************************************************************
+ * h2_sos_mplx
+ ******************************************************************************/
+
+typedef struct h2_sos_mplx {
+ h2_mplx *m;
+ apr_bucket_brigade *bb;
+ apr_table_t *trailers;
+} h2_sos_mplx;
+
+#define H2_SOS_MPLX_OUT(lvl,msos,msg) \
+ do { \
+ if (APLOG_C_IS_LEVEL((msos)->m->c,lvl)) \
+ h2_util_bb_log((msos)->m->c,(msos)->m->id,lvl,msg,(msos)->bb); \
+ } while(0)
+
+
+static apr_status_t h2_sos_mplx_read_to(h2_sos *sos, apr_bucket_brigade *bb,
+ apr_off_t *plen, int *peos)
+{
+ h2_sos_mplx *msos = sos->ctx;
+ apr_status_t status = APR_SUCCESS;
+ apr_table_t *trailers = NULL;
+
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx read_to_pre");
+
+ if (APR_BRIGADE_EMPTY(msos->bb)) {
+ apr_off_t tlen = *plen;
+ int eos;
+ status = h2_mplx_out_read_to(msos->m, sos->stream->id,
+ msos->bb, &tlen, &eos, &trailers);
+ }
+
+ if (status == APR_SUCCESS && !APR_BRIGADE_EMPTY(msos->bb)) {
+ status = h2_transfer_brigade(bb, msos->bb, sos->stream->pool,
+ plen, peos);
+ }
+ else {
+ *plen = 0;
+ *peos = 0;
+ }
+
+ if (trailers) {
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, msos->m->c,
+ "h2_stream(%ld-%d): read_to, saving trailers",
+ msos->m->id, sos->stream->id);
+ msos->trailers = trailers;
+ }
+
+ if (status == APR_SUCCESS && !*peos && !*plen) {
+ status = APR_EAGAIN;
+ }
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx read_to_post");
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, msos->m->c,
+ "h2_stream(%ld-%d): read_to, len=%ld eos=%d",
+ msos->m->id, sos->stream->id, (long)*plen, *peos);
+ return status;
+}
+
+static apr_status_t h2_sos_mplx_prep_read(h2_sos *sos, apr_off_t *plen, int *peos)
+{
+ h2_sos_mplx *msos = sos->ctx;
+ apr_status_t status = APR_SUCCESS;
+ const char *src;
+ apr_table_t *trailers = NULL;
+ int test_read = (*plen == 0);
+
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx prep_read_pre");
+ if (!APR_BRIGADE_EMPTY(msos->bb)) {
+ src = "stream";
+ status = h2_util_bb_avail(msos->bb, plen, peos);
+ if (!test_read && status == APR_SUCCESS && !*peos && !*plen) {
+ apr_brigade_cleanup(msos->bb);
+ return h2_sos_mplx_prep_read(sos, plen, peos);
+ }
+ }
+ else {
+ src = "mplx";
+ status = h2_mplx_out_readx(msos->m, sos->stream->id,
+ NULL, NULL, plen, peos, &trailers);
+ if (trailers) {
+ msos->trailers = trailers;
+ }
+ }
+
+ if (!test_read && status == APR_SUCCESS && !*peos && !*plen) {
+ status = APR_EAGAIN;
+ }
+
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx prep_read_post");
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, msos->m->c,
+ "h2_stream(%ld-%d): prep_read %s, len=%ld eos=%d, trailers=%s",
+ msos->m->id, sos->stream->id, src, (long)*plen, *peos,
+ msos->trailers? "yes" : "no");
+ return status;
+}
+
+static apr_status_t h2_sos_mplx_readx(h2_sos *sos, h2_io_data_cb *cb, void *ctx,
+ apr_off_t *plen, int *peos)
+{
+ h2_sos_mplx *msos = sos->ctx;
+ apr_status_t status = APR_SUCCESS;
+ apr_table_t *trailers = NULL;
+ const char *src;
+
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx readx_pre");
+ *peos = 0;
+ if (!APR_BRIGADE_EMPTY(msos->bb)) {
+ apr_off_t origlen = *plen;
+
+ src = "stream";
+ status = h2_util_bb_readx(msos->bb, cb, ctx, plen, peos);
+ if (status == APR_SUCCESS && !*peos && !*plen) {
+ apr_brigade_cleanup(msos->bb);
+ *plen = origlen;
+ return h2_sos_mplx_readx(sos, cb, ctx, plen, peos);
+ }
+ }
+ else {
+ src = "mplx";
+ status = h2_mplx_out_readx(msos->m, sos->stream->id,
+ cb, ctx, plen, peos, &trailers);
+ }
+
+ if (trailers) {
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, msos->m->c,
+ "h2_stream(%ld-%d): readx, saving trailers",
+ msos->m->id, sos->stream->id);
+ msos->trailers = trailers;
+ }
+
+ if (status == APR_SUCCESS && !*peos && !*plen) {
+ status = APR_EAGAIN;
+ }
+
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_stream readx_post");
+ ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, msos->m->c,
+ "h2_stream(%ld-%d): readx %s, len=%ld eos=%d",
+ msos->m->id, sos->stream->id, src, (long)*plen, *peos);
+
+ return status;
+}
+
+static apr_table_t *h2_sos_mplx_get_trailers(h2_sos *sos)
+{
+ h2_sos_mplx *msos = sos->ctx;
+
+ return msos->trailers;
+}
+
+static apr_status_t h2_sos_mplx_buffer(h2_sos *sos, apr_bucket_brigade *bb)
+{
+ h2_sos_mplx *msos = sos->ctx;
+ apr_status_t status = APR_SUCCESS;
+
+ if (bb && !APR_BRIGADE_EMPTY(bb)) {
+ apr_size_t move_all = INT_MAX;
+ /* we can move file handles from h2_mplx into this h2_stream as many
+ * as we want, since the lifetimes are the same and we are not freeing
+ * the ones in h2_mplx->io before this stream is done. */
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx set_response_pre");
+ status = h2_util_move(msos->bb, bb, 16 * 1024, &move_all,
+ "h2_stream_set_response");
+ H2_SOS_MPLX_OUT(APLOG_TRACE2, msos, "h2_sos_mplx set_response_post");
+ }
+ return status;
+}
+
+static h2_sos *h2_sos_mplx_create(h2_stream *stream, h2_response *response)
+{
+ h2_sos *sos;
+ h2_sos_mplx *msos;
+
+ msos = apr_pcalloc(stream->pool, sizeof(*msos));
+ msos->m = stream->session->mplx;
+ msos->bb = apr_brigade_create(stream->pool, msos->m->c->bucket_alloc);
+
+ sos = apr_pcalloc(stream->pool, sizeof(*sos));
+ sos->stream = stream;
+ sos->response = response;
+
+ sos->ctx = msos;
+ sos->buffer = h2_sos_mplx_buffer;
+ sos->prep_read = h2_sos_mplx_prep_read;
+ sos->readx = h2_sos_mplx_readx;
+ sos->read_to = h2_sos_mplx_read_to;
+ sos->get_trailers = h2_sos_mplx_get_trailers;
+
+ sos->response = response;
+
+ return sos;
+}
+
struct h2_request;
struct h2_response;
struct h2_session;
-struct h2_task;
+struct h2_sos;
typedef struct h2_stream h2_stream;
apr_pool_t *pool; /* the memory pool for this stream */
struct h2_request *request; /* the request made in this stream */
- struct h2_response *response; /* the response, once ready */
int rst_error; /* stream error for RST_STREAM */
unsigned int aborted : 1; /* was aborted */
apr_off_t input_remaining; /* remaining bytes on input as advertised via content-length */
apr_bucket_brigade *bbin; /* input DATA */
-
- apr_bucket_brigade *bbout; /* output DATA */
+
+ struct h2_sos *sos; /* stream output source, e.g. to read output from */
apr_off_t data_frames_sent; /* # of DATA frames sent out for this stream */
};
*/
int h2_stream_is_scheduled(h2_stream *stream);
+struct h2_response *h2_stream_get_response(h2_stream *stream);
+
/**
* Set the response for this stream. Invoked when all meta data for
* the stream response has been collected.
apr_status_t h2_stream_read_to(h2_stream *stream, apr_bucket_brigade *bb,
apr_off_t *plen, int *peos);
+/**
+ * Get optional trailers for this stream, may be NULL. Meaningful
+ * results can only be expected when the end of the response body has
+ * been reached.
+ *
+ * @param stream to ask for trailers
+ * @return trailers for NULL
+ */
+apr_table_t *h2_stream_get_trailers(h2_stream *stream);
+
/**
* Set the suspended state of the stream.
* @param stream the stream to change state on
*/
apr_status_t h2_stream_submit_pushes(h2_stream *stream);
-/**
- * Get optional trailers for this stream, may be NULL. Meaningful
- * results can only be expected when the end of the response body has
- * been reached.
- *
- * @param stream to ask for trailers
- * @return trailers for NULL
- */
-apr_table_t *h2_stream_get_trailers(h2_stream *stream);
-
/**
* Get priority information set for this stream.
*/
}
}
-static const int BASE64URL_TABLE[] = {
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57,
- 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
- 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1
+static const int BASE64URL_UINT6[] = {
+/* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0 */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 1 */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, /* 2 */
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 3 */
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 4 */
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63, /* 5 */
+ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 6 */
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, /* 7 */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 8 */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 9 */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* a */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* b */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* c */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* d */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* e */
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 /* f */
+};
+static const char BASE64URL_CHARS[] = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', /* 0 - 9 */
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', /* 10 - 19 */
+ 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', /* 20 - 29 */
+ 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', /* 30 - 39 */
+ 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', /* 40 - 49 */
+ 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', /* 50 - 59 */
+ '8', '9', '-', '_', ' ', ' ', ' ', ' ', ' ', ' ', /* 60 - 69 */
};
apr_size_t h2_util_base64url_decode(const char **decoded, const char *encoded,
int n;
apr_size_t len, mlen, remain, i;
- while (*p && BASE64URL_TABLE[ *p ] == -1) {
+ while (*p && BASE64URL_UINT6[ *p ] != -1) {
++p;
}
len = p - e;
i = 0;
d = (unsigned char*)*decoded;
for (; i < mlen; i += 4) {
- n = ((BASE64URL_TABLE[ e[i+0] ] << 18) +
- (BASE64URL_TABLE[ e[i+1] ] << 12) +
- (BASE64URL_TABLE[ e[i+2] ] << 6) +
- BASE64URL_TABLE[ e[i+3] ]);
+ n = ((BASE64URL_UINT6[ e[i+0] ] << 18) +
+ (BASE64URL_UINT6[ e[i+1] ] << 12) +
+ (BASE64URL_UINT6[ e[i+2] ] << 6) +
+ (BASE64URL_UINT6[ e[i+3] ]));
*d++ = n >> 16;
*d++ = n >> 8 & 0xffu;
*d++ = n & 0xffu;
remain = len - mlen;
switch (remain) {
case 2:
- n = ((BASE64URL_TABLE[ e[mlen+0] ] << 18) +
- (BASE64URL_TABLE[ e[mlen+1] ] << 12));
+ n = ((BASE64URL_UINT6[ e[mlen+0] ] << 18) +
+ (BASE64URL_UINT6[ e[mlen+1] ] << 12));
*d++ = n >> 16;
break;
case 3:
- n = ((BASE64URL_TABLE[ e[mlen+0] ] << 18) +
- (BASE64URL_TABLE[ e[mlen+1] ] << 12) +
- (BASE64URL_TABLE[ e[mlen+2] ] << 6));
+ n = ((BASE64URL_UINT6[ e[mlen+0] ] << 18) +
+ (BASE64URL_UINT6[ e[mlen+1] ] << 12) +
+ (BASE64URL_UINT6[ e[mlen+2] ] << 6));
*d++ = n >> 16;
*d++ = n >> 8 & 0xffu;
break;
default: /* do nothing */
break;
}
- return len;
+ return mlen/4*3 + remain;
+}
+
+const char *h2_util_base64url_encode(const char *data,
+ apr_size_t len, apr_pool_t *pool)
+{
+ apr_size_t mlen = ((len+2)/3)*3;
+ apr_size_t slen = (mlen/3)*4;
+ apr_size_t i;
+ const unsigned char *udata = (const unsigned char*)data;
+ char *enc, *p = apr_pcalloc(pool, slen+1); /* 0 terminated */
+
+ enc = p;
+ for (i = 0; i < mlen; i+= 3) {
+ *p++ = BASE64URL_CHARS[ (udata[i] >> 2) & 0x3fu ];
+ *p++ = BASE64URL_CHARS[ (udata[i] << 4) +
+ ((i+1 < len)? (udata[i+1] >> 4) : 0) & 0x3fu ];
+ *p++ = BASE64URL_CHARS[ (udata[i+1] << 2) +
+ ((i+2 < len)? (udata[i+2] >> 6) : 0) & 0x3fu ];
+ *p++ = (i+2 < len)? BASE64URL_CHARS[ udata[i+2] & 0x3fu ] : '=';
+ }
+
+ return enc;
}
int h2_util_contains_token(apr_pool_t *pool, const char *s, const char *token)
apr_size_t h2_util_base64url_decode(const char **decoded,
const char *encoded,
apr_pool_t *pool);
+const char *h2_util_base64url_encode(const char *data,
+ apr_size_t len, apr_pool_t *pool);
#define H2_HD_MATCH_LIT(l, name, nlen) \
((nlen == sizeof(l) - 1) && !apr_strnatcasecmp(l, name))
#include <apr_want.h>
#include <httpd.h>
+#include <http_protocol.h>
#include <http_request.h>
#include <http_log.h>
#include "h2_stream.h"
#include "h2_alt_svc.h"
#include "h2_conn.h"
+#include "h2_filter.h"
#include "h2_task.h"
#include "h2_session.h"
#include "h2_config.h"
/* Setup subprocess env for certain variables
*/
ap_hook_fixups(h2_h2_fixups, NULL,NULL, APR_HOOK_MIDDLE);
+
+ /* test http2 connection status handler */
+ ap_hook_handler(h2_filter_h2_status_handler, NULL, NULL, APR_HOOK_MIDDLE);
}
static char *value_of_HTTP2(apr_pool_t *p, server_rec *s,
projects / thirdparty / apache / httpd.git / commitdiff
