import apache 2.x module portion of apreq

git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@1200457 13f79535-47bb-0310-9956-ffa450edef68

5 files changed, 1260 insertions, 0 deletions

diff --git a/modules/apreq/Makefile.am b/modules/apreq/Makefile.am
new file mode 100644
index 0000000000..230dbbee9d
--- /dev/null
+++ b/modules/apreq/Makefile.am
@@ -0,0 +1,41 @@
+TEST_CONFIG_SCRIPT = package Apache::TestMM; filter_args(); generate_script("t/TEST")
+mod_apreq2_la_LDFLAGS = -export-dynamic -module -avoid-version \
+                        `@APREQ_CONFIG@ --link-libtool --libs` @APR_LTFLAGS@
+mod_apreq2_la_SOURCES = apreq_private_apache2.h handle.c filter.c
+
+pkgcfgdir = `@APACHE2_APXS@ -q SYSCONFDIR`
+pkgincludedir = `@APACHE2_APXS@ -q INCLUDEDIR`/@APREQ_LIBNAME@
+pkglibdir = `@APACHE2_APXS@ -q LIBEXECDIR`
+
+AM_CPPFLAGS = @APACHE2_INCLUDES@ @APR_INCLUDES@
+
+if BUILD_HTTPD
+
+# XXX FIXME: static builds don't work anymore
+# mod_apreq2 needs to be built from httpd-2.X, e.g.
+#
+# % cd ../httpd-2.X;
+# % ./configure --with-module=filters:../httpd-apreq-2/module/apache2/mod_apreq2.c ...
+#
+# See the INSTALL file for details.
+
+@APACHE2_HTTPD@:
+	cd @APACHE2_SRC@ && $(MAKE)
+
+all-local: @APACHE2_HTTPD@
+
+else
+
+pkginclude_HEADERS = apreq_module_apache2.h
+pkglib_LTLIBRARIES = mod_apreq2.la
+
+install-exec-local :
+	@echo "----------------------------------------------------------------------"
+	@echo "Before you can use mod_apreq2, you must ensure that an appropriate"
+	@echo "\"LoadModule\" line appears in your webserver's config file:"
+	@echo "$(pkgcfgdir)/httpd.conf"
+	@echo 
+	@echo "LoadModule apreq_module    $(pkglibdir)/mod_apreq2.so"
+	@echo "----------------------------------------------------------------------"
+
+endif
diff --git a/modules/apreq/apreq_module_apache2.h b/modules/apreq/apreq_module_apache2.h
new file mode 100644
index 0000000000..e1642f5f67
--- /dev/null
+++ b/modules/apreq/apreq_module_apache2.h
@@ -0,0 +1,182 @@
+/*
+**  Licensed to the Apache Software Foundation (ASF) under one or more
+** contributor license agreements.  See the NOTICE file distributed with
+** this work for additional information regarding copyright ownership.
+** The ASF licenses this file to You under the Apache License, Version 2.0
+** (the "License"); you may not use this file except in compliance with
+** the License.  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+#ifndef APREQ_APACHE2_H
+#define APREQ_APACHE2_H
+
+#include "apreq_module.h"
+#include "apr_optional.h"
+#include <httpd.h>
+
+#ifdef  __cplusplus
+ extern "C" {
+#endif
+
+
+/**
+ * @defgroup mod_apreq2 Apache 2.X Filter Module
+ * @ingroup apreq_module
+ * @brief mod_apreq2 - DSO that ties libapreq2 to Apache HTTPD 2.X.
+ *
+ * mod_apreq2 provides the "APREQ2" input filter for using libapreq2
+ * (and allow its parsed data structures to be shared) within
+ * the Apache 2.X webserver.  Using it, libapreq2 works properly
+ * in every phase of the HTTP request, from translation handlers
+ * to output filters, and even for subrequests / internal redirects.
+ *
+ * <hr>
+ *
+ * <h2>Activating mod_apreq2 in Apache 2.X</h2>
+ *
+ * The installation process triggered by
+ * <code>% make install</code>
+ * <em>will not modify your webserver's config file</em>. Hence,
+ * be sure you activate it on startup by adding a LoadModule directive
+ * to your webserver config; e.g.
+ *
+ * @code
+ *
+ *     LoadModule apreq_module    modules/mod_apreq2.so
+ *
+ * @endcode
+ *
+ * The mod_apreq2 filter is named "apreq2", and may be used in Apache's
+ * input filter directives, e.g.
+ * @code
+ *
+ *     AddInputFilter apreq2         # or
+ *     SetInputFilter apreq2
+ *
+ * @endcode
+ *
+ * However, this is not required because libapreq2 will add the filter (only)
+ * if it's necessary.  You just need to ensure that your module invokes
+ * apreq_handle_apache2() <em>before the content handler ultimately reads
+ * from the input filter chain</em>.  It is important to realize that no
+ * matter how the input filters are initially arranged, the APREQ2 filter
+ * will attempt to reposition itself to be the last input filter to read the
+ * data.
+ *
+ * If you want to use other input filters to transform the incoming HTTP
+ * request data, is important to register those filters with Apache
+ * as having type AP_FTYPE_CONTENT_SET or AP_FTYPE_RESOURCE.  Due to the
+ * limitations of Apache's current input filter design, types higher than
+ * AP_FTYPE_CONTENT_SET may not work properly whenever the apreq filter is
+ * active.
+ *
+ * This is especially true when a content handler uses libapreq2 to parse
+ * some of the post data before doing an internal redirect.  Any input
+ * filter subsequently added to the redirected request will bypass the
+ * original apreq filter (and therefore lose access to some of the original
+ * post data), unless its type is less than the type of the apreq filter
+ * (currently AP_FTYPE_PROTOCOL-1).
+ *
+ *
+ * <H2>Server Configuration Directives</H2>
+ *
+ * <TABLE class="qref">
+ *   <CAPTION>Per-directory commands for mod_apreq2</CAPTION>
+ *   <TR>
+ *     <TH>Directive</TH>
+ *     <TH>Context</TH>
+ *     <TH>Default</TH><TH>Description</TH>
+ *   </TR>
+ *   <TR class="odd">
+ *     <TD>APREQ2_ReadLimit</TD>
+ *     <TD>directory</TD>
+ *     <TD> #APREQ_DEFAULT_READ_LIMIT </TD>
+ *     <TD> Maximum number of bytes mod_apreq2 will send off to libapreq2
+ *          for parsing. mod_apreq2 will log this event and subsequently
+ *          remove itself from the filter chain.
+ *     </TD>
+ *   </TR>
+ *   <TR>
+ *     <TD>APREQ2_BrigadeLimit</TD>
+ *     <TD>directory</TD>
+ *     <TD>#APREQ_DEFAULT_BRIGADE_LIMIT</TD>
+ *     <TD> Maximum number of bytes mod_apreq2 will let accumulate
+ *          within the heap-buckets in a brigade.  Excess data will be
+ *          spooled to an appended file bucket.
+ *     </TD>
+ *   </TR>
+ *   <TR class="odd">
+ *     <TD>APREQ2_TempDir</TD>
+ *     <TD>directory</TD>
+ *     <TD>NULL</TD>
+ *     <TD> Sets the location of the temporary directory apreq will use to spool
+ *          overflow brigade data (based on the APREQ2_BrigadeLimit setting).
+ *          If left unset, libapreq2 will select a platform-specific location
+ *          via apr_temp_dir_get().
+ *     </TD>
+ *  </TR>
+ * </TABLE>
+ *
+ * <H2>Implementation Details</H2>
+ * <PRE>
+ *   XXX apreq as a normal input filter
+ *   XXX apreq as a "virtual" content handler.
+ *   XXX apreq as a transparent "tee".
+ *   XXX apreq parser registration in post_config
+ * </PRE>
+ *
+ * @{
+ */
+/**
+ * Create an apreq handle which communicates with an Apache 2.X
+ * request_rec.
+ */
+APREQ_DECLARE(apreq_handle_t *) apreq_handle_apache2(request_rec *r);
+
+/**
+ *
+ *      
+ */
+#ifdef WIN32
+typedef __declspec(dllexport) apreq_handle_t *
+(__stdcall apr_OFN_apreq_handle_apache2_t) (request_rec *r);
+#else
+APR_DECLARE_OPTIONAL_FN(APREQ_DECLARE(apreq_handle_t *),
+                        apreq_handle_apache2, (request_rec *r));
+#endif
+
+/**
+ * The mod_apreq2 filter is named "apreq2", and may be used in Apache's
+ * input filter directives, e.g.
+ * @code
+ *
+ *     AddInputFilter apreq2         # or
+ *     SetInputFilter apreq2
+ * @endcode
+ * See above
+ */
+#define APREQ_FILTER_NAME "apreq2"
+
+/**
+ * The Apache2 Module Magic Number for use in the Apache 2.x module structures
+ * This gets bumped if changes in th4e API will break third party applications
+ * using this apache2 module
+ * @see APREQ_MODULE
+ */
+#define APREQ_APACHE2_MMN 20101207
+
+/** @} */
+
+#ifdef __cplusplus
+ }
+#endif
+
+#endif
diff --git a/modules/apreq/apreq_private_apache2.h b/modules/apreq/apreq_private_apache2.h
new file mode 100644
index 0000000000..173060dc48
--- /dev/null
+++ b/modules/apreq/apreq_private_apache2.h
@@ -0,0 +1,56 @@
+extern module AP_MODULE_DECLARE_DATA apreq_module;
+
+struct dir_config {
+    const char         *temp_dir;
+    apr_uint64_t        read_limit;
+    apr_size_t          brigade_limit;
+};
+
+/* The "warehouse", stored in r->request_config */
+struct apache2_handle {
+    apreq_handle_t      handle;
+    request_rec        *r;
+    apr_table_t        *jar, *args;
+    apr_status_t        jar_status, args_status;
+    ap_filter_t        *f;
+};
+
+/* Tracks the apreq filter state */
+struct filter_ctx {
+    apr_bucket_brigade *bb;    /* input brigade that's passed to the parser */
+    apr_bucket_brigade *bbtmp; /* temporary copy of bb, destined for the spool */
+    apr_bucket_brigade *spool; /* copied prefetch data for downstream filters */
+    apreq_parser_t     *parser;
+    apreq_hook_t       *hook_queue;
+    apreq_hook_t       *find_param;
+    apr_table_t        *body;
+    apr_status_t        body_status;
+    apr_status_t        filter_error;
+    apr_uint64_t        bytes_read;     /* Total bytes read into this filter. */
+    apr_uint64_t        read_limit;     /* Max bytes the filter may show to parser */
+    apr_size_t          brigade_limit;
+    const char         *temp_dir;
+};
+
+apr_status_t apreq_filter_prefetch(ap_filter_t *f, apr_off_t readbytes);
+apr_status_t apreq_filter(ap_filter_t *f,
+                          apr_bucket_brigade *bb,
+                          ap_input_mode_t mode,
+                          apr_read_type_e block,
+                          apr_off_t readbytes);
+
+void apreq_filter_make_context(ap_filter_t *f);
+void apreq_filter_init_context(ap_filter_t *f);
+
+APR_INLINE
+static void apreq_filter_relocate(ap_filter_t *f)
+{
+    request_rec *r = f->r;
+
+    if (f != r->input_filters) {
+        ap_filter_t *top = r->input_filters;
+        ap_remove_input_filter(f);
+        r->input_filters = f;
+        f->next = top;
+    }
+}
diff --git a/modules/apreq/filter.c b/modules/apreq/filter.c
new file mode 100644
index 0000000000..ef122ba450
--- /dev/null
+++ b/modules/apreq/filter.c
@@ -0,0 +1,540 @@
+/*
+**  Licensed to the Apache Software Foundation (ASF) under one or more
+** contributor license agreements.  See the NOTICE file distributed with
+** this work for additional information regarding copyright ownership.
+** The ASF licenses this file to You under the Apache License, Version 2.0
+** (the "License"); you may not use this file except in compliance with
+** the License.  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+#include "httpd.h"
+#include "http_config.h"
+#include "http_log.h"
+#include "util_filter.h"
+#include "apr_tables.h"
+#include "apr_buckets.h"
+#include "http_request.h"
+#include "apr_strings.h"
+
+#include "apreq_module_apache2.h"
+#include "apreq_private_apache2.h"
+#include "apreq_error.h"
+#include "apreq_util.h"
+#include "apreq_version.h"
+
+static void *apreq_create_dir_config(apr_pool_t *p, char *d)
+{
+    /* d == OR_ALL */
+    struct dir_config *dc = apr_palloc(p, sizeof *dc);
+    dc->temp_dir      = NULL;
+    dc->read_limit    = -1;
+    dc->brigade_limit = -1;
+    return dc;
+}
+
+static void *apreq_merge_dir_config(apr_pool_t *p, void *a_, void *b_)
+{
+    struct dir_config *a = a_, *b = b_, *c = apr_palloc(p, sizeof *c);
+
+    c->temp_dir      = (b->temp_dir != NULL)            /* overrides ok */
+                      ? b->temp_dir : a->temp_dir;
+
+    c->brigade_limit = (b->brigade_limit == (apr_size_t)-1) /* overrides ok */
+                      ? a->brigade_limit : b->brigade_limit;
+
+    c->read_limit    = (b->read_limit < a->read_limit)  /* yes, min */
+                      ? b->read_limit : a->read_limit;
+
+    return c;
+}
+
+static const char *apreq_set_temp_dir(cmd_parms *cmd, void *data,
+                                      const char *arg)
+{
+    struct dir_config *conf = data;
+    const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
+
+    if (err != NULL)
+        return err;
+
+    conf->temp_dir = arg;
+    return NULL;
+}
+
+static const char *apreq_set_read_limit(cmd_parms *cmd, void *data,
+                                        const char *arg)
+{
+    struct dir_config *conf = data;
+    const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
+
+    if (err != NULL)
+        return err;
+
+    conf->read_limit = apreq_atoi64f(arg);
+    return NULL;
+}
+
+static const char *apreq_set_brigade_limit(cmd_parms *cmd, void *data,
+                                           const char *arg)
+{
+    struct dir_config *conf = data;
+    const char *err = ap_check_cmd_context(cmd, NOT_IN_LIMIT);
+
+    if (err != NULL)
+        return err;
+
+    conf->brigade_limit = apreq_atoi64f(arg);
+    return NULL;
+}
+
+
+static const command_rec apreq_cmds[] =
+{
+    AP_INIT_TAKE1("APREQ2_TempDir", apreq_set_temp_dir, NULL, OR_ALL,
+                  "Default location of temporary directory"),
+    AP_INIT_TAKE1("APREQ2_ReadLimit", apreq_set_read_limit, NULL, OR_ALL,
+                  "Maximum amount of data that will be fed into a parser."),
+    AP_INIT_TAKE1("APREQ2_BrigadeLimit", apreq_set_brigade_limit, NULL, OR_ALL,
+                  "Maximum in-memory bytes a brigade may use."),
+    { NULL }
+};
+
+
+void apreq_filter_init_context(ap_filter_t *f)
+{
+    request_rec *r = f->r;
+    struct filter_ctx *ctx = f->ctx;
+    apr_bucket_alloc_t *ba = r->connection->bucket_alloc;
+    const char *cl_header;
+
+    if (r->method_number == M_GET) {
+        /* Don't parse GET (this protects against subrequest body parsing). */
+        ctx->body_status = APREQ_ERROR_NODATA;
+        return;
+    }
+
+    cl_header = apr_table_get(r->headers_in, "Content-Length");
+
+    if (cl_header != NULL) {
+        char *dummy;
+        apr_uint64_t content_length = apr_strtoi64(cl_header,&dummy,0);
+
+        if (dummy == NULL || *dummy != 0) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, r,
+                          "Invalid Content-Length header (%s)", cl_header);
+            ctx->body_status = APREQ_ERROR_BADHEADER;
+            return;
+        }
+        else if (content_length > ctx->read_limit) {
+            ap_log_rerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, r,
+                          "Content-Length header (%s) exceeds configured "
+                          "max_body limit (%" APR_UINT64_T_FMT ")",
+                          cl_header, ctx->read_limit);
+            ctx->body_status = APREQ_ERROR_OVERLIMIT;
+            return;
+        }
+    }
+
+    if (ctx->parser == NULL) {
+        const char *ct_header = apr_table_get(r->headers_in, "Content-Type");
+
+        if (ct_header != NULL) {
+            apreq_parser_function_t pf = apreq_parser(ct_header);
+
+            if (pf != NULL) {
+                ctx->parser = apreq_parser_make(r->pool, ba, ct_header, pf,
+                                                ctx->brigade_limit,
+                                                ctx->temp_dir,
+                                                ctx->hook_queue,
+                                                NULL);
+            }
+            else {
+                ctx->body_status = APREQ_ERROR_NOPARSER;
+                return;
+            }
+        }
+        else {
+            ctx->body_status = APREQ_ERROR_NOHEADER;
+            return;
+        }
+    }
+    else {
+        if (ctx->parser->brigade_limit > ctx->brigade_limit)
+            ctx->parser->brigade_limit = ctx->brigade_limit;
+        if (ctx->temp_dir != NULL)
+            ctx->parser->temp_dir = ctx->temp_dir;
+        if (ctx->hook_queue != NULL)
+            apreq_parser_add_hook(ctx->parser, ctx->hook_queue);
+    }
+
+    ctx->hook_queue = NULL;
+    ctx->bb    = apr_brigade_create(r->pool, ba);
+    ctx->bbtmp = apr_brigade_create(r->pool, ba);
+    ctx->spool = apr_brigade_create(r->pool, ba);
+    ctx->body  = apr_table_make(r->pool, APREQ_DEFAULT_NELTS);
+    ctx->body_status = APR_INCOMPLETE;
+}
+
+
+/*
+ * Situations to contend with:
+ *
+ * 1) Often the filter will be added by the content handler itself,
+ *    so the apreq_filter_init hook will not be run.
+ * 2) If an auth handler uses apreq, the apreq_filter will ensure
+ *    it's part of the protocol filters.  apreq_filter_init does NOT need
+ *    to notify the protocol filter that it must not continue parsing,
+ *    the apreq filter can perform this check itself.  apreq_filter_init
+ *    just needs to ensure cfg->f does not point at it.
+ * 3) If req->proto_input_filters and req->input_filters are apreq
+ *    filters, and req->input_filters->next == req->proto_input_filters,
+ *    it is safe for apreq_filter to "steal" the proto filter's context
+ *    and subsequently drop it from the chain.
+ */
+
+
+/* Examines the input_filter chain and moves the apreq filter(s) around
+ * before the filter chain is stacked by ap_get_brigade.
+ */
+
+
+static apr_status_t apreq_filter_init(ap_filter_t *f)
+{
+    request_rec *r = f->r;
+    struct filter_ctx *ctx = f->ctx;
+    struct apache2_handle *handle =
+        (struct apache2_handle *)apreq_handle_apache2(r);
+
+    /* Don't parse GET (this protects against subrequest body parsing). */
+    if (f->r->method_number == M_GET)
+        return APR_SUCCESS;
+
+    if (ctx == NULL || ctx->body_status == APR_EINIT) {
+        if (f == r->input_filters) {
+            handle->f = f;
+        }
+        else if (r->input_filters->frec->filter_func.in_func == apreq_filter) {
+            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r,
+                          "removing intermediate apreq filter");
+            if (handle->f == f)
+                handle->f = r->input_filters;
+            ap_remove_input_filter(f);
+        }
+        else {
+            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r,
+                          "relocating intermediate apreq filter");
+            apreq_filter_relocate(f);
+            handle->f = f;
+        }
+        return APR_SUCCESS;
+    }
+
+    /* else this is a protocol filter which may still be active.
+     * if it is, we must deregister it now.
+     */
+    if (handle->f == f) {
+        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r,
+                     "disabling stale protocol filter");
+        if (ctx->body_status == APR_INCOMPLETE)
+            ctx->body_status = APREQ_ERROR_INTERRUPT;
+        handle->f = NULL;
+    }
+    return APR_SUCCESS;
+}
+
+
+
+apr_status_t apreq_filter_prefetch(ap_filter_t *f, apr_off_t readbytes)
+{
+    struct filter_ctx *ctx = f->ctx;
+    request_rec *r = f->r;
+    apr_status_t rv;
+    apr_off_t len;
+
+    if (ctx->body_status == APR_EINIT)
+        apreq_filter_init_context(f);
+
+    if (ctx->body_status != APR_INCOMPLETE || readbytes == 0)
+        return ctx->body_status;
+
+    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r,
+                  "prefetching %" APR_OFF_T_FMT " bytes", readbytes);
+
+    rv = ap_get_brigade(f->next, ctx->bb, AP_MODE_READBYTES,
+                       APR_BLOCK_READ, readbytes);
+
+    if (rv != APR_SUCCESS) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
+                      "ap_get_brigade failed during prefetch");
+        ctx->filter_error = rv;
+        return ctx->body_status = APREQ_ERROR_GENERAL;
+    }
+
+    apreq_brigade_setaside(ctx->bb, r->pool);
+    apreq_brigade_copy(ctx->bbtmp, ctx->bb);
+
+    rv = apreq_brigade_concat(r->pool, ctx->temp_dir, ctx->brigade_limit,
+                              ctx->spool, ctx->bbtmp);
+    if (rv != APR_SUCCESS && rv != APR_EOF) {
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
+                      "apreq_brigade_concat failed; TempDir problem?");
+        ctx->filter_error = APR_EGENERAL;
+        return ctx->body_status = rv;
+    }
+
+    /* Adding "f" to the protocol filter chain ensures the
+     * spooled data is preserved across internal redirects.
+     */
+
+    if (f != r->proto_input_filters) {
+        ap_filter_t *in;
+        for (in = r->input_filters; in != r->proto_input_filters;
+             in = in->next)
+        {
+            if (f == in) {
+                r->proto_input_filters = f;
+                break;
+            }
+        }
+    }
+
+    apr_brigade_length(ctx->bb, 1, &len);
+    ctx->bytes_read += len;
+
+    if (ctx->bytes_read > ctx->read_limit) {
+        ctx->body_status = APREQ_ERROR_OVERLIMIT;
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, ctx->body_status, r,
+                      "Bytes read (%" APR_UINT64_T_FMT
+                      ") exceeds configured read limit (%" APR_UINT64_T_FMT ")",
+                      ctx->bytes_read, ctx->read_limit);
+        return ctx->body_status;
+    }
+
+    ctx->body_status = apreq_parser_run(ctx->parser, ctx->body, ctx->bb);
+    apr_brigade_cleanup(ctx->bb);
+
+    return ctx->body_status;
+}
+
+
+
+apr_status_t apreq_filter(ap_filter_t *f,
+                          apr_bucket_brigade *bb,
+                          ap_input_mode_t mode,
+                          apr_read_type_e block,
+                          apr_off_t readbytes)
+{
+    request_rec *r = f->r;
+    struct filter_ctx *ctx;
+    apr_status_t rv;
+    apr_off_t len;
+
+    switch (mode) {
+    case AP_MODE_READBYTES:
+        /* only the modes above are supported */
+        break;
+
+    case AP_MODE_EXHAUSTIVE: /* not worth supporting at this level */
+    case AP_MODE_GETLINE: /* chunked trailers are b0rked in ap_http_filter */
+        return ap_get_brigade(f->next, bb, mode, block, readbytes);
+
+    default:
+        return APR_ENOTIMPL;
+    }
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    if (ctx->body_status == APR_EINIT)
+        apreq_filter_init_context(f);
+
+    if (ctx->spool && !APR_BRIGADE_EMPTY(ctx->spool)) {
+        apr_bucket *e;
+        rv = apr_brigade_partition(ctx->spool, readbytes, &e);
+        if (rv != APR_SUCCESS && rv != APR_INCOMPLETE)
+            return rv;
+
+        if (APR_BUCKET_IS_EOS(e))
+            e = APR_BUCKET_NEXT(e);
+
+        apreq_brigade_move(bb, ctx->spool, e);
+        return APR_SUCCESS;
+    }
+    else if (ctx->body_status != APR_INCOMPLETE) {
+        if (ctx->filter_error)
+            return ctx->filter_error;
+
+        rv = ap_get_brigade(f->next, bb, mode, block, readbytes);
+        ap_remove_input_filter(f);
+        return rv;
+    }
+
+
+    rv = ap_get_brigade(f->next, bb, mode, block, readbytes);
+    if (rv != APR_SUCCESS)
+        return rv;
+
+    apreq_brigade_copy(ctx->bb, bb);
+    apr_brigade_length(bb, 1, &len);
+    ctx->bytes_read += len;
+
+    if (ctx->bytes_read > ctx->read_limit) {
+        ctx->body_status = APREQ_ERROR_OVERLIMIT;
+        ap_log_rerror(APLOG_MARK, APLOG_ERR, ctx->body_status, r,
+                      "Bytes read (%" APR_UINT64_T_FMT
+                      ") exceeds configured max_body limit (%"
+                      APR_UINT64_T_FMT ")",
+                      ctx->bytes_read, ctx->read_limit);
+    }
+    else {
+        ctx->body_status = apreq_parser_run(ctx->parser, ctx->body, ctx->bb);
+        apr_brigade_cleanup(ctx->bb);
+    }
+    return APR_SUCCESS;
+}
+
+
+static int apreq_pre_init(apr_pool_t *p, apr_pool_t *plog,
+                          apr_pool_t *ptemp, server_rec *base_server)
+{
+    apr_status_t status;
+
+    status = apreq_pre_initialize(p);
+    if (status != APR_SUCCESS) {
+        ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, status, base_server,
+                     "Failed to pre-initialize libapreq2");
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+    APR_REGISTER_OPTIONAL_FN(apreq_handle_apache2);
+    return OK;
+}
+
+static int apreq_post_init(apr_pool_t *p, apr_pool_t *plog,
+                           apr_pool_t *ptemp, server_rec *base_server)
+{
+    apr_status_t status;
+
+    ap_add_version_component(p, apr_psprintf(p,
+                                             "mod_apreq2-%d/%s",
+                                             APREQ_APACHE2_MMN,
+                                             apreq_version_string()));
+
+    status = apreq_post_initialize(p);
+    if (status != APR_SUCCESS) {
+        ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_ERR, status, base_server,
+                     "Failed to post-initialize libapreq2");
+        return HTTP_INTERNAL_SERVER_ERROR;
+    }
+    return OK;
+}
+
+static void register_hooks (apr_pool_t *p)
+{
+    /* APR_HOOK_FIRST because we want other modules to be able to
+     * register parsers in their post_config hook via APR_HOOK_MIDDLE.
+     */
+    ap_hook_post_config(apreq_pre_init, NULL, NULL, APR_HOOK_FIRST);
+
+    /* APR_HOOK_LAST because we need to lock the default_parsers hash
+     * (to prevent further modifications) before the server forks.
+     */
+    ap_hook_post_config(apreq_post_init, NULL, NULL, APR_HOOK_LAST);
+
+    ap_register_input_filter(APREQ_FILTER_NAME, apreq_filter, apreq_filter_init,
+                             AP_FTYPE_PROTOCOL-1);
+}
+
+
+
+/** @} */
+
+
+module AP_MODULE_DECLARE_DATA apreq_module = {
+#line __LINE__ "mod_apreq2.c"
+	STANDARD20_MODULE_STUFF,
+	apreq_create_dir_config,
+	apreq_merge_dir_config,
+	NULL,
+	NULL,
+	apreq_cmds,
+	register_hooks,
+};
+
+
+void apreq_filter_make_context(ap_filter_t *f)
+{
+    request_rec *r;
+    struct filter_ctx *ctx;
+    struct dir_config *d;
+
+    r = f->r;
+    d = ap_get_module_config(r->per_dir_config, &apreq_module);
+
+    if (f == r->input_filters
+        && r->proto_input_filters == f->next
+        && f->next->frec->filter_func.in_func == apreq_filter
+        && f->r->method_number != M_GET)
+    {
+
+        ctx = f->next->ctx;
+
+        switch (ctx->body_status) {
+
+        case APREQ_ERROR_INTERRUPT:
+            ctx->body_status = APR_INCOMPLETE;
+            /* fall thru */
+
+        case APR_SUCCESS:
+
+            if (d != NULL) {
+                ctx->temp_dir      = d->temp_dir;
+                ctx->read_limit    = d->read_limit;
+                ctx->brigade_limit = d->brigade_limit;
+
+                if (ctx->parser != NULL) {
+                    ctx->parser->temp_dir = d->temp_dir;
+                    ctx->parser->brigade_limit = d->brigade_limit;
+                }
+
+            }
+
+            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, APR_SUCCESS, r,
+                          "stealing filter context");
+            f->ctx = ctx;
+            r->proto_input_filters = f;
+            ap_remove_input_filter(f->next);
+
+            return;
+
+        default:
+            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, ctx->body_status, r,
+                          "cannot steal context: bad filter status");
+        }
+    }
+
+    ctx = apr_pcalloc(r->pool, sizeof *ctx);
+    ctx->body_status = APR_EINIT;
+
+    if (d == NULL) {
+        ctx->read_limit    = (apr_uint64_t)-1;
+        ctx->brigade_limit = APREQ_DEFAULT_BRIGADE_LIMIT;
+    } else {
+        ctx->temp_dir      = d->temp_dir;
+        ctx->read_limit    = (d->read_limit == (apr_uint64_t)-1)
+            ? APREQ_DEFAULT_READ_LIMIT : d->read_limit;
+        ctx->brigade_limit = (d->brigade_limit == (apr_size_t)-1)
+            ? APREQ_DEFAULT_BRIGADE_LIMIT : d->brigade_limit;
+    }
+
+    f->ctx = ctx;
+}
diff --git a/modules/apreq/handle.c b/modules/apreq/handle.c
new file mode 100644
index 0000000000..2de02dd229
--- /dev/null
+++ b/modules/apreq/handle.c
@@ -0,0 +1,441 @@
+/*
+**  Licensed to the Apache Software Foundation (ASF) under one or more
+** contributor license agreements.  See the NOTICE file distributed with
+** this work for additional information regarding copyright ownership.
+** The ASF licenses this file to You under the Apache License, Version 2.0
+** (the "License"); you may not use this file except in compliance with
+** the License.  You may obtain a copy of the License at
+**
+**      http://www.apache.org/licenses/LICENSE-2.0
+**
+**  Unless required by applicable law or agreed to in writing, software
+**  distributed under the License is distributed on an "AS IS" BASIS,
+**  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+**  See the License for the specific language governing permissions and
+**  limitations under the License.
+*/
+
+#include "httpd.h"
+#include "http_config.h"
+#include "http_log.h"
+#include "util_filter.h"
+#include "apr_tables.h"
+#include "apr_buckets.h"
+#include "http_request.h"
+#include "apr_strings.h"
+
+#include "apreq_module_apache2.h"
+#include "apreq_private_apache2.h"
+#include "apreq_error.h"
+
+
+APR_INLINE
+static ap_filter_t *get_apreq_filter(apreq_handle_t *handle)
+{
+    struct apache2_handle *req = (struct apache2_handle *)handle;
+
+    if (req->f == NULL) {
+        req->f = ap_add_input_filter(APREQ_FILTER_NAME, NULL,
+                                     req->r,
+                                     req->r->connection);
+        /* ap_add_input_filter does not guarantee cfg->f == r->input_filters,
+         * so we reposition the new filter there as necessary.
+         */
+        apreq_filter_relocate(req->f);
+    }
+
+    return req->f;
+}
+
+
+static apr_status_t apache2_jar(apreq_handle_t *handle, const apr_table_t **t)
+{
+    struct apache2_handle *req = (struct apache2_handle*)handle;
+    request_rec *r = req->r;
+
+    if (req->jar_status == APR_EINIT) {
+        const char *cookies = apr_table_get(r->headers_in, "Cookie");
+        if (cookies != NULL) {
+            req->jar = apr_table_make(handle->pool, APREQ_DEFAULT_NELTS);
+            req->jar_status =
+                apreq_parse_cookie_header(handle->pool, req->jar, cookies);
+        }
+        else
+            req->jar_status = APREQ_ERROR_NODATA;
+    }
+
+    *t = req->jar;
+    return req->jar_status;
+}
+
+static apr_status_t apache2_args(apreq_handle_t *handle, const apr_table_t **t)
+{
+    struct apache2_handle *req = (struct apache2_handle*)handle;
+    request_rec *r = req->r;
+
+    if (req->args_status == APR_EINIT) {
+        if (r->args != NULL) {
+            req->args = apr_table_make(handle->pool, APREQ_DEFAULT_NELTS);
+            req->args_status =
+                apreq_parse_query_string(handle->pool, req->args, r->args);
+        }
+        else
+            req->args_status = APREQ_ERROR_NODATA;
+    }
+
+    *t = req->args;
+    return req->args_status;
+}
+
+
+
+
+static apreq_cookie_t *apache2_jar_get(apreq_handle_t *handle, const char *name)
+{
+    struct apache2_handle *req = (struct apache2_handle *)handle;
+    const apr_table_t *t;
+    const char *val;
+
+    if (req->jar_status == APR_EINIT)
+        apache2_jar(handle, &t);
+    else
+        t = req->jar;
+
+    if (t == NULL)
+        return NULL;
+
+    val = apr_table_get(t, name);
+    if (val == NULL)
+        return NULL;
+
+    return apreq_value_to_cookie(val);
+}
+
+static apreq_param_t *apache2_args_get(apreq_handle_t *handle, const char *name)
+{
+    struct apache2_handle *req = (struct apache2_handle *)handle;
+    const apr_table_t *t;
+    const char *val;
+
+    if (req->args_status == APR_EINIT)
+        apache2_args(handle, &t);
+    else
+        t = req->args;
+
+    if (t == NULL)
+        return NULL;
+
+    val = apr_table_get(t, name);
+    if (val == NULL)
+        return NULL;
+
+    return apreq_value_to_param(val);
+}
+
+
+static apr_status_t apache2_body(apreq_handle_t *handle, const apr_table_t **t)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    switch (ctx->body_status) {
+
+    case APR_EINIT:
+        apreq_filter_init_context(f);
+        if (ctx->body_status != APR_INCOMPLETE)
+            break;
+
+    case APR_INCOMPLETE:
+        while (apreq_filter_prefetch(f, APREQ_DEFAULT_READ_BLOCK_SIZE) == APR_INCOMPLETE)
+            ;   /*loop*/
+    }
+
+    *t = ctx->body;
+    return ctx->body_status;
+}
+
+static apreq_param_t *apache2_body_get(apreq_handle_t *handle, const char *name)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+    const char *val;
+    apreq_hook_t *h;
+    apreq_hook_find_param_ctx_t *hook_ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    switch (ctx->body_status) {
+
+    case APR_SUCCESS:
+
+        val = apr_table_get(ctx->body, name);
+        if (val != NULL)
+            return apreq_value_to_param(val);
+        return NULL;
+
+
+    case APR_EINIT:
+
+        apreq_filter_init_context(f);
+        if (ctx->body_status != APR_INCOMPLETE)
+            return NULL;
+        apreq_filter_prefetch(f, APREQ_DEFAULT_READ_BLOCK_SIZE);
+
+
+    case APR_INCOMPLETE:
+
+        val = apr_table_get(ctx->body, name);
+        if (val != NULL)
+            return apreq_value_to_param(val);
+
+        /* Not seen yet, so we need to scan for
+           param while prefetching the body */
+        hook_ctx = apr_palloc(handle->pool, sizeof *hook_ctx);
+
+        if (ctx->find_param == NULL)
+            ctx->find_param = apreq_hook_make(handle->pool,
+                                              apreq_hook_find_param,
+                                              NULL, NULL);
+        h = ctx->find_param;
+        h->next = ctx->parser->hook;
+        h->ctx = hook_ctx;
+        ctx->parser->hook = h;
+        h->ctx = hook_ctx;
+        hook_ctx->name = name;
+        hook_ctx->param = NULL;
+        hook_ctx->prev = ctx->parser->hook;
+
+        do {
+            apreq_filter_prefetch(f, APREQ_DEFAULT_READ_BLOCK_SIZE);
+            if (hook_ctx->param != NULL)
+                return hook_ctx->param;
+        } while (ctx->body_status == APR_INCOMPLETE);
+
+        ctx->parser->hook = h->next;
+        return NULL;
+
+
+    default:
+
+        if (ctx->body == NULL)
+            return NULL;
+
+        val = apr_table_get(ctx->body, name);
+        if (val != NULL)
+            return apreq_value_to_param(val);
+        return NULL;
+
+    }
+
+    /* not reached */
+    return NULL;
+}
+
+static
+apr_status_t apache2_parser_get(apreq_handle_t *handle,
+                                  const apreq_parser_t **parser)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx = f->ctx;
+
+    if (ctx == NULL) {
+        *parser = NULL;
+        return APR_EINIT;
+    }
+    *parser = ctx->parser;
+    return APR_SUCCESS;
+}
+
+static
+apr_status_t apache2_parser_set(apreq_handle_t *handle,
+                                apreq_parser_t *parser)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    if (ctx->parser == NULL) {
+        ctx->parser = parser;
+        return APR_SUCCESS;
+    }
+    else
+        return APREQ_ERROR_NOTEMPTY;
+}
+
+
+
+static
+apr_status_t apache2_hook_add(apreq_handle_t *handle,
+                              apreq_hook_t *hook)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    if (ctx->parser != NULL) {
+        return apreq_parser_add_hook(ctx->parser, hook);
+    }
+    else if (ctx->hook_queue != NULL) {
+        apreq_hook_t *h = ctx->hook_queue;
+        while (h->next != NULL)
+            h = h->next;
+        h->next = hook;
+    }
+    else {
+        ctx->hook_queue = hook;
+    }
+    return APR_SUCCESS;
+
+}
+
+static
+apr_status_t apache2_brigade_limit_set(apreq_handle_t *handle,
+                                       apr_size_t bytes)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    if (ctx->body_status == APR_EINIT || ctx->brigade_limit > bytes) {
+        ctx->brigade_limit = bytes;
+        return APR_SUCCESS;
+    }
+
+    return APREQ_ERROR_MISMATCH;
+}
+
+static
+apr_status_t apache2_brigade_limit_get(apreq_handle_t *handle,
+                                       apr_size_t *bytes)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+    *bytes = ctx->brigade_limit;
+    return APR_SUCCESS;
+}
+
+static
+apr_status_t apache2_read_limit_set(apreq_handle_t *handle,
+                                    apr_uint64_t bytes)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+
+    if (ctx->read_limit > bytes && ctx->bytes_read < bytes) {
+        ctx->read_limit = bytes;
+        return APR_SUCCESS;
+    }
+
+    return APREQ_ERROR_MISMATCH;
+}
+
+static
+apr_status_t apache2_read_limit_get(apreq_handle_t *handle,
+                                    apr_uint64_t *bytes)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+    *bytes = ctx->read_limit;
+    return APR_SUCCESS;
+}
+
+static
+apr_status_t apache2_temp_dir_set(apreq_handle_t *handle,
+                                  const char *path)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+    // init vs incomplete state?
+    if (ctx->temp_dir == NULL && ctx->bytes_read == 0) {
+        if (path != NULL)
+            ctx->temp_dir = apr_pstrdup(handle->pool, path);
+        return APR_SUCCESS;
+    }
+
+    return APREQ_ERROR_NOTEMPTY;
+}
+
+static
+apr_status_t apache2_temp_dir_get(apreq_handle_t *handle,
+                                  const char **path)
+{
+    ap_filter_t *f = get_apreq_filter(handle);
+    struct filter_ctx *ctx;
+
+    if (f->ctx == NULL)
+        apreq_filter_make_context(f);
+
+    ctx = f->ctx;
+    *path = ctx->parser ? ctx->parser->temp_dir : ctx->temp_dir;
+    return APR_SUCCESS;
+}
+
+static APREQ_MODULE(apache2, APREQ_APACHE2_MMN);
+
+APREQ_DECLARE(apreq_handle_t *) apreq_handle_apache2(request_rec *r)
+{
+    struct apache2_handle *req =
+        ap_get_module_config(r->request_config, &apreq_module);
+
+    if (req != NULL) {
+        get_apreq_filter(&req->handle);
+        return &req->handle;
+    }
+
+    req = apr_palloc(r->pool, sizeof *req);
+    ap_set_module_config(r->request_config, &apreq_module, req);
+
+    req->handle.module = &apache2_module;
+    req->handle.pool = r->pool;
+    req->handle.bucket_alloc = r->connection->bucket_alloc;
+    req->r = r;
+
+    req->args_status = req->jar_status = APR_EINIT;
+    req->args = req->jar = NULL;
+
+    req->f = NULL;
+
+    get_apreq_filter(&req->handle);
+    return &req->handle;
+
+}