You are viewing a plain text version of this content. The canonical link for it is here.
Posted to cvs@httpd.apache.org by yl...@apache.org on 2018/09/05 17:27:43 UTC

svn commit: r1840149 - in /httpd/httpd/trunk: include/ap_mmn.h include/httpd.h include/util_filter.h modules/http/http_request.c server/core_filters.c server/request.c server/util.c server/util_filter.c

Author: ylavic
Date: Wed Sep  5 17:27:43 2018
New Revision: 1840149

URL: http://svn.apache.org/viewvc?rev=1840149&view=rev
Log:
util_filter: protect ap_filter_t private fields from external (ab)use.

Introduce opaque struct ap_filter_private to move ap_filter_t "pending", "bb"
and "deferred_pool" fields to the "priv" side of things.

This allows to trust values set internally (only!) in util_filter code, and
make useful assertions between the different functions calls, along with the
usual nice extensibility property.

Likewise, the private struct ap_filter_conn_ctx in conn_rec (from r1839997)
allows now to implement the new ap_acquire_brigade() and ap_release_brigade()
functions useful to get a brigade with c->pool's lifetime. They obsolete
ap_reuse_brigade_from_pool() which is replaced where previously used.

Some comments added in ap_request_core_filter() regarding the lifetime of the
data it plays with, up to EOR...

MAJOR bumped (once again).

Modified:
    httpd/httpd/trunk/include/ap_mmn.h
    httpd/httpd/trunk/include/httpd.h
    httpd/httpd/trunk/include/util_filter.h
    httpd/httpd/trunk/modules/http/http_request.c
    httpd/httpd/trunk/server/core_filters.c
    httpd/httpd/trunk/server/request.c
    httpd/httpd/trunk/server/util.c
    httpd/httpd/trunk/server/util_filter.c

Modified: httpd/httpd/trunk/include/ap_mmn.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/include/ap_mmn.h?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/include/ap_mmn.h (original)
+++ httpd/httpd/trunk/include/ap_mmn.h Wed Sep  5 17:27:43 2018
@@ -602,14 +602,18 @@
  *                         filter_conn_ctx, remove argument pool from
  *                         ap_filter_prepare_brigade()
  * 20180903.2 (2.5.1-dev)  Add ap_filter_recycle()
+ * 20180905.1 (2.5.1-dev)  Axe ap_reuse_brigade_from_pool(), replaced by
+ *                         ap_acquire_brigade()/ap_release_brigade(), and
+ *                         and replace pending/bb/deferred_pool fields in
+ *                         ap_filter_t by struct ap_filter_private priv field
  */
 
 #define MODULE_MAGIC_COOKIE 0x41503235UL /* "AP25" */
 
 #ifndef MODULE_MAGIC_NUMBER_MAJOR
-#define MODULE_MAGIC_NUMBER_MAJOR 20180903
+#define MODULE_MAGIC_NUMBER_MAJOR 20180905
 #endif
-#define MODULE_MAGIC_NUMBER_MINOR 2                 /* 0...n */
+#define MODULE_MAGIC_NUMBER_MINOR 1                 /* 0...n */
 
 /**
  * Determine if the server's current MODULE_MAGIC_NUMBER is at least a

Modified: httpd/httpd/trunk/include/httpd.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/include/httpd.h?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/include/httpd.h (original)
+++ httpd/httpd/trunk/include/httpd.h Wed Sep  5 17:27:43 2018
@@ -1111,7 +1111,7 @@ typedef enum {
     AP_CONN_KEEPALIVE
 } ap_conn_keepalive_e;
 
-/* For struct ap_filter_conn_ctx */
+/* For struct ap_filter and ap_filter_conn_ctx */
 #include "util_filter.h"
 
 /**
@@ -1224,7 +1224,7 @@ struct conn_rec {
     /** Array of requests being handled under this connection. */
     apr_array_header_t *requests;
 
-    /** Filters' context for this connection */
+    /** Filters private/opaque context for this connection */
     struct ap_filter_conn_ctx *filter_conn_ctx;
 
     /** The minimum level of filter type to allow setaside buckets */
@@ -2194,19 +2194,6 @@ AP_DECLARE(int) ap_request_has_body(requ
 AP_DECLARE(int) ap_request_tainted(request_rec *r, int flags);
 
 /**
- * Reuse a brigade from a pool, or create it on the given pool/alloc and
- * associate it with the given key for further reuse.
- *
- * @param key the key/id of the brigade
- * @param pool the pool to cache and create the brigade from
- * @param alloc the bucket allocator to be used by the brigade
- * @return the reused and cleaned up brigade, or a new one
- */
-AP_DECLARE(apr_bucket_brigade *) ap_reuse_brigade_from_pool(const char *key,
-                                                            apr_pool_t *pool,
-                                                    apr_bucket_alloc_t *alloc);
-
-/**
  * Cleanup a string (mainly to be filesystem safe)
  * We only allow '_' and alphanumeric chars. Non-printable
  * map to 'x' and all others map to '_'

Modified: httpd/httpd/trunk/include/util_filter.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/include/util_filter.h?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/include/util_filter.h (original)
+++ httpd/httpd/trunk/include/util_filter.h Wed Sep  5 17:27:43 2018
@@ -264,6 +264,11 @@ struct ap_filter_rec_t {
 };
 
 /**
+ * @brief The private/opaque data in ap_filter_t.
+ */
+struct ap_filter_private;
+
+/**
  * @brief The representation of a filter chain.
  *
  * Each request has a list
@@ -293,22 +298,30 @@ struct ap_filter_t {
      */
     conn_rec *c;
 
-    /** Buffered data associated with the current filter. */
-    apr_bucket_brigade *bb;
-
-    /** Dedicated pool to use for deferred writes. */
-    apr_pool_t *deferred_pool;
-
-    /** Entry in ring of pending filters (with setaside buckets). */
-    APR_RING_ENTRY(ap_filter_t) pending;
+    /** Filter private/opaque data */
+    struct ap_filter_private *priv;
 };
 
 /**
- * @brief The filters' context in conn_rec (opaque).
+ * @brief The filters private/opaque context in conn_rec.
  */
 struct ap_filter_conn_ctx;
 
 /**
+ * Acquire a brigade created on the connection pool/alloc.
+ * @param c The connection
+ * @return The brigade (cleaned up)
+ */
+AP_DECLARE(apr_bucket_brigade *) ap_acquire_brigade(conn_rec *c);
+
+/**
+ * Release and cleanup a brigade (created on the connection pool/alloc!).
+ * @param c The connection
+ * @param bb The brigade
+ */
+AP_DECLARE(void) ap_release_brigade(conn_rec *c, apr_bucket_brigade *bb);
+
+/**
  * Get the current bucket brigade from the next filter on the filter
  * stack.  The filter returns an apr_status_t value.  If the bottom-most
  * filter doesn't read from the network, then ::AP_NOBODY_READ is returned.

Modified: httpd/httpd/trunk/modules/http/http_request.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http/http_request.c?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http/http_request.c (original)
+++ httpd/httpd/trunk/modules/http/http_request.c Wed Sep  5 17:27:43 2018
@@ -352,11 +352,12 @@ AP_DECLARE(void) ap_process_request_afte
     conn_rec *c = r->connection;
     ap_filter_t *f;
 
+    bb = ap_acquire_brigade(c);
+
     /* Send an EOR bucket through the output filter chain.  When
      * this bucket is destroyed, the request will be logged and
      * its pool will be freed
      */
-    bb = ap_reuse_brigade_from_pool("ap_prah_bb", c->pool, c->bucket_alloc);
     b = ap_bucket_eor_create(c->bucket_alloc, r);
     APR_BRIGADE_INSERT_HEAD(bb, b);
 
@@ -399,7 +400,8 @@ AP_DECLARE(void) ap_process_request_afte
      * until the next/real request comes in or the keepalive timeout expires.
      */
     (void)ap_check_pipeline(c, bb, DEFAULT_LIMIT_BLANK_LINES);
-    apr_brigade_cleanup(bb);
+
+    ap_release_brigade(c, bb);
 
     if (!c->aborted) {
         ap_filter_recycle(c);
@@ -507,7 +509,7 @@ AP_DECLARE(void) ap_process_request(requ
     ap_process_async_request(r);
 
     if (ap_run_input_pending(c) != OK) {
-        bb = ap_reuse_brigade_from_pool("ap_pr_bb", c->pool, c->bucket_alloc);
+        bb = ap_acquire_brigade(c);
         b = apr_bucket_flush_create(c->bucket_alloc);
         APR_BRIGADE_INSERT_HEAD(bb, b);
         rv = ap_pass_brigade(c->output_filters, bb);
@@ -520,7 +522,7 @@ AP_DECLARE(void) ap_process_request(requ
             ap_log_cerror(APLOG_MARK, APLOG_INFO, rv, c, APLOGNO(01581)
                           "flushing data to the client");
         }
-        apr_brigade_cleanup(bb);
+        ap_release_brigade(c, bb);
     }
     if (ap_extended_status) {
         ap_time_process_request(c->sbh, STOP_PREQUEST);

Modified: httpd/httpd/trunk/server/core_filters.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/server/core_filters.c?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/server/core_filters.c (original)
+++ httpd/httpd/trunk/server/core_filters.c Wed Sep  5 17:27:43 2018
@@ -85,6 +85,7 @@ struct core_output_filter_ctx {
 };
 
 struct core_filter_ctx {
+    apr_bucket_brigade *bb;
     apr_bucket_brigade *tmpbb;
 };
 
@@ -116,19 +117,19 @@ apr_status_t ap_core_input_filter(ap_fil
     if (!ctx)
     {
         net->in_ctx = ctx = apr_palloc(f->c->pool, sizeof(*ctx));
-        ap_filter_prepare_brigade(f);
+        ctx->bb = apr_brigade_create(f->c->pool, f->c->bucket_alloc);
         ctx->tmpbb = apr_brigade_create(f->c->pool, f->c->bucket_alloc);
         /* seed the brigade with the client socket. */
-        rv = ap_run_insert_network_bucket(f->c, f->bb, net->client_socket);
+        rv = ap_run_insert_network_bucket(f->c, ctx->bb, net->client_socket);
         if (rv != APR_SUCCESS)
             return rv;
     }
-    else if (APR_BRIGADE_EMPTY(f->bb)) {
+    else if (APR_BRIGADE_EMPTY(ctx->bb)) {
         return APR_EOF;
     }
 
     /* ### This is bad. */
-    BRIGADE_NORMALIZE(f->bb);
+    BRIGADE_NORMALIZE(ctx->bb);
 
     /* check for empty brigade again *AFTER* BRIGADE_NORMALIZE()
      * If we have lost our socket bucket (see above), we are EOF.
@@ -136,13 +137,13 @@ apr_status_t ap_core_input_filter(ap_fil
      * Ideally, this should be returning SUCCESS with EOS bucket, but
      * some higher-up APIs (spec. read_request_line via ap_rgetline)
      * want an error code. */
-    if (APR_BRIGADE_EMPTY(f->bb)) {
+    if (APR_BRIGADE_EMPTY(ctx->bb)) {
         return APR_EOF;
     }
 
     if (mode == AP_MODE_GETLINE) {
         /* we are reading a single LF line, e.g. the HTTP headers */
-        rv = apr_brigade_split_line(b, f->bb, block, HUGE_STRING_LEN);
+        rv = apr_brigade_split_line(b, ctx->bb, block, HUGE_STRING_LEN);
         /* We should treat EAGAIN here the same as we do for EOF (brigade is
          * empty).  We do this by returning whatever we have read.  This may
          * or may not be bogus, but is consistent (for now) with EOF logic.
@@ -170,10 +171,10 @@ apr_status_t ap_core_input_filter(ap_fil
          * mean that there is another request, just a blank line.
          */
         while (1) {
-            if (APR_BRIGADE_EMPTY(f->bb))
+            if (APR_BRIGADE_EMPTY(ctx->bb))
                 return APR_EOF;
 
-            e = APR_BRIGADE_FIRST(f->bb);
+            e = APR_BRIGADE_FIRST(ctx->bb);
 
             rv = apr_bucket_read(e, &str, &len, APR_NONBLOCK_READ);
 
@@ -212,7 +213,7 @@ apr_status_t ap_core_input_filter(ap_fil
         apr_bucket *e;
 
         /* Tack on any buckets that were set aside. */
-        APR_BRIGADE_CONCAT(b, f->bb);
+        APR_BRIGADE_CONCAT(b, ctx->bb);
 
         /* Since we've just added all potential buckets (which will most
          * likely simply be the socket bucket) we know this is the end,
@@ -230,7 +231,7 @@ apr_status_t ap_core_input_filter(ap_fil
 
         AP_DEBUG_ASSERT(readbytes > 0);
 
-        e = APR_BRIGADE_FIRST(f->bb);
+        e = APR_BRIGADE_FIRST(ctx->bb);
         rv = apr_bucket_read(e, &str, &len, block);
 
         if (APR_STATUS_IS_EAGAIN(rv) && block == APR_NONBLOCK_READ) {
@@ -247,7 +248,7 @@ apr_status_t ap_core_input_filter(ap_fil
              *
              * When we are in normal mode, return an EOS bucket to the
              * caller.
-             * When we are in speculative mode, leave ctx->b empty, so
+             * When we are in speculative mode, leave ctx->bb empty, so
              * that the next call returns an EOS bucket.
              */
             apr_bucket_delete(e);
@@ -267,7 +268,7 @@ apr_status_t ap_core_input_filter(ap_fil
             /* We already registered the data in e in len */
             e = APR_BUCKET_NEXT(e);
             while ((len < readbytes) && (rv == APR_SUCCESS)
-                   && (e != APR_BRIGADE_SENTINEL(f->bb))) {
+                   && (e != APR_BRIGADE_SENTINEL(ctx->bb))) {
                 /* Check for the availability of buckets with known length */
                 if (e->length != -1) {
                     len += e->length;
@@ -295,22 +296,22 @@ apr_status_t ap_core_input_filter(ap_fil
             readbytes = len;
         }
 
-        rv = apr_brigade_partition(f->bb, readbytes, &e);
+        rv = apr_brigade_partition(ctx->bb, readbytes, &e);
         if (rv != APR_SUCCESS) {
             return rv;
         }
 
         /* Must do move before CONCAT */
-        ctx->tmpbb = apr_brigade_split_ex(f->bb, e, ctx->tmpbb);
+        ctx->tmpbb = apr_brigade_split_ex(ctx->bb, e, ctx->tmpbb);
 
         if (mode == AP_MODE_READBYTES) {
-            APR_BRIGADE_CONCAT(b, f->bb);
+            APR_BRIGADE_CONCAT(b, ctx->bb);
         }
         else if (mode == AP_MODE_SPECULATIVE) {
             apr_bucket *copy_bucket;
 
-            for (e = APR_BRIGADE_FIRST(f->bb);
-                 e != APR_BRIGADE_SENTINEL(f->bb);
+            for (e = APR_BRIGADE_FIRST(ctx->bb);
+                 e != APR_BRIGADE_SENTINEL(ctx->bb);
                  e = APR_BUCKET_NEXT(e))
             {
                 rv = apr_bucket_copy(e, &copy_bucket);
@@ -321,8 +322,8 @@ apr_status_t ap_core_input_filter(ap_fil
             }
         }
 
-        /* Take what was originally there and place it back on ctx->b */
-        APR_BRIGADE_CONCAT(f->bb, ctx->tmpbb);
+        /* Take what was originally there and place it back on ctx->bb */
+        APR_BRIGADE_CONCAT(ctx->bb, ctx->tmpbb);
     }
     return APR_SUCCESS;
 }

Modified: httpd/httpd/trunk/server/request.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/server/request.c?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/server/request.c (original)
+++ httpd/httpd/trunk/server/request.c Wed Sep  5 17:27:43 2018
@@ -2068,7 +2068,7 @@ AP_CORE_DECLARE_NONSTD(apr_status_t) ap_
 {
     apr_bucket *flush_upto = NULL;
     apr_status_t status = APR_SUCCESS;
-    apr_bucket_brigade *tmp_bb = f->ctx;
+    apr_bucket_brigade *tmp_bb;
     int seen_eor = 0;
 
     /*
@@ -2080,15 +2080,17 @@ AP_CORE_DECLARE_NONSTD(apr_status_t) ap_
         return ap_pass_brigade(f->next, bb);
     }
 
-    if (!tmp_bb) {
-        f->ctx = tmp_bb = ap_reuse_brigade_from_pool("ap_rcf_bb", f->c->pool,
-                                                     f->c->bucket_alloc);
-    }
-
     /* Reinstate any buffered content */
     ap_filter_reinstate_brigade(f, bb, &flush_upto);
 
-    while (!APR_BRIGADE_EMPTY(bb)) {
+    /* After EOR is passed downstream, anything pooled on the request may
+     * be destroyed (including bb!), but not tmp_bb which is acquired from
+     * c->pool (and released after the below loop).
+     */
+    tmp_bb = ap_acquire_brigade(f->c);
+
+    /* Don't touch *bb after seen_eor */
+    while (status == APR_SUCCESS && !seen_eor && !APR_BRIGADE_EMPTY(bb)) {
         apr_bucket *bucket = APR_BRIGADE_FIRST(bb);
 
         if (AP_BUCKET_IS_EOR(bucket)) {
@@ -2118,10 +2120,9 @@ AP_CORE_DECLARE_NONSTD(apr_status_t) ap_
                     && bucket->length == (apr_size_t)-1) {
                 const char *data;
                 apr_size_t size;
-                if (APR_SUCCESS
-                        != (status = apr_bucket_read(bucket, &data, &size,
-                                APR_BLOCK_READ))) {
-                    return status;
+                status = apr_bucket_read(bucket, &data, &size, APR_BLOCK_READ);
+                if (status != APR_SUCCESS) {
+                    break;
                 }
             }
 
@@ -2132,13 +2133,15 @@ AP_CORE_DECLARE_NONSTD(apr_status_t) ap_
 
         status = ap_pass_brigade(f->next, tmp_bb);
         apr_brigade_cleanup(tmp_bb);
-
-        if (status != APR_SUCCESS || seen_eor) {
-            return status;
-        }
     }
 
-    return ap_filter_setaside_brigade(f, bb);
+    ap_release_brigade(f->c, tmp_bb);
+
+    /* Don't touch *bb after seen_eor */
+    if (status == APR_SUCCESS && !seen_eor) {
+        status = ap_filter_setaside_brigade(f, bb);
+    }
+    return status;
 }
 
 extern APR_OPTIONAL_FN_TYPE(authz_some_auth_required) *ap__authz_ap_some_auth_required;

Modified: httpd/httpd/trunk/server/util.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/server/util.c?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/server/util.c (original)
+++ httpd/httpd/trunk/server/util.c Wed Sep  5 17:27:43 2018
@@ -2679,22 +2679,6 @@ AP_DECLARE_NONSTD(apr_status_t) ap_pool_
     return APR_SUCCESS;
 }
 
-AP_DECLARE(apr_bucket_brigade *) ap_reuse_brigade_from_pool(const char *key,
-                                                            apr_pool_t *pool,
-                                                    apr_bucket_alloc_t *alloc)
-{
-    apr_bucket_brigade *bb = NULL;
-    apr_pool_userdata_get((void **)&bb, key, pool);
-    if (bb == NULL) {
-        bb = apr_brigade_create(pool, alloc);
-        apr_pool_userdata_set(bb, key, NULL, pool);
-    }
-    else {
-        apr_brigade_cleanup(bb);
-    }
-    return bb;
-}
-
 AP_DECLARE(apr_status_t) ap_str2_alnum(const char *src, char *dest) {
 
     for ( ; *src; src++, dest++)

Modified: httpd/httpd/trunk/server/util_filter.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/server/util_filter.c?rev=1840149&r1=1840148&r2=1840149&view=diff
==============================================================================
--- httpd/httpd/trunk/server/util_filter.c (original)
+++ httpd/httpd/trunk/server/util_filter.c Wed Sep  5 17:27:43 2018
@@ -51,22 +51,34 @@
 #undef APLOG_MODULE_INDEX
 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
 
+struct ap_filter_private {
+    /* Link to a pending_ring (keep first preferably) */
+    APR_RING_ENTRY(ap_filter_private) pending;
+
+    /* Backref to owning filter */
+    ap_filter_t *f;
+
+    /* Pending buckets */
+    apr_bucket_brigade *bb;
+    /* Dedicated pool to use for deferred writes. */
+    apr_pool_t *deferred_pool;
+};
+APR_RING_HEAD(pending_ring, ap_filter_private);
+
 struct spare_data {
     APR_RING_ENTRY(spare_data) link;
     void *data;
 };
-
-APR_RING_HEAD(ap_filter_ring, ap_filter_t);
-APR_RING_HEAD(ap_filter_spare_ring, spare_data);
+APR_RING_HEAD(spare_ring, spare_data);
 
 struct ap_filter_conn_ctx {
-    struct ap_filter_ring *pending_input_filters;
-    struct ap_filter_ring *pending_output_filters;
+    struct pending_ring *pending_input_filters;
+    struct pending_ring *pending_output_filters;
 
-    struct ap_filter_spare_ring *spare_containers,
-                                *spare_brigades,
-                                *spare_filters,
-                                *dead_filters;
+    struct spare_ring *spare_containers,
+                      *spare_brigades,
+                      *spare_filters,
+                      *dead_filters;
 };
 
 typedef struct filter_trie_node filter_trie_node;
@@ -309,7 +321,7 @@ static struct ap_filter_conn_ctx *get_co
     return x;
 }
 
-static void make_spare_ring(struct ap_filter_spare_ring **ring, apr_pool_t *p)
+static void make_spare_ring(struct spare_ring **ring, apr_pool_t *p)
 {
     if (!*ring) {
         *ring = apr_palloc(p, sizeof(**ring));
@@ -317,7 +329,7 @@ static void make_spare_ring(struct ap_fi
     }
 }
 
-static void *get_spare(conn_rec *c, struct ap_filter_spare_ring *ring)
+static void *get_spare(conn_rec *c, struct spare_ring *ring)
 {
     void *data = NULL;
 
@@ -335,8 +347,7 @@ static void *get_spare(conn_rec *c, stru
     return data;
 }
 
-static void put_spare(conn_rec *c, void *data,
-                      struct ap_filter_spare_ring **ring)
+static void put_spare(conn_rec *c, void *data, struct spare_ring **ring)
 {
     struct ap_filter_conn_ctx *x = c->filter_conn_ctx;
     struct spare_data *sdata;
@@ -355,6 +366,24 @@ static void put_spare(conn_rec *c, void
     APR_RING_INSERT_TAIL(*ring, sdata, spare_data, link);
 }
 
+AP_DECLARE(apr_bucket_brigade *) ap_acquire_brigade(conn_rec *c)
+{
+    struct ap_filter_conn_ctx *x = get_conn_ctx(c);
+    apr_bucket_brigade *bb = get_spare(c, x->spare_brigades);
+
+    return bb ? bb : apr_brigade_create(c->pool, c->bucket_alloc);
+}
+
+AP_DECLARE(void) ap_release_brigade(conn_rec *c, apr_bucket_brigade *bb)
+{
+    struct ap_filter_conn_ctx *x = get_conn_ctx(c);
+
+    AP_DEBUG_ASSERT(bb->p == c->pool && bb->bucket_alloc == c->bucket_alloc);
+
+    apr_brigade_cleanup(bb);
+    put_spare(c, bb, &x->spare_brigades);
+}
+
 static apr_status_t request_filter_cleanup(void *arg)
 {
     ap_filter_t *f = arg;
@@ -395,6 +424,7 @@ static ap_filter_t *add_any_filter_handl
     ap_filter_t *f;
     ap_filter_t **outf;
     struct ap_filter_conn_ctx *x;
+    struct ap_filter_private *fp;
 
     if (frec->ftype < AP_FTYPE_PROTOCOL) {
         if (r) {
@@ -422,10 +452,18 @@ static ap_filter_t *add_any_filter_handl
 
     x = get_conn_ctx(c);
     f = get_spare(c, x->spare_filters);
-    if (!f) {
+    if (f) {
+        fp = f->priv;
+    }
+    else {
         f = apr_palloc(c->pool, sizeof(*f));
+        fp = apr_palloc(c->pool, sizeof(*fp));
     }
     memset(f, 0, sizeof(*f));
+    memset(fp, 0, sizeof(*fp));
+    APR_RING_ELEM_INIT(fp, pending);
+    f->priv = fp;
+    fp->f = f;
 
     f->frec = frec;
     f->ctx = ctx;
@@ -436,7 +474,6 @@ static ap_filter_t *add_any_filter_handl
         f->r = r;
     }
     f->c = c;
-    APR_RING_ELEM_INIT(f, pending);
 
     if (INSERT_BEFORE(f, *outf)) {
         f->next = *outf;
@@ -562,22 +599,23 @@ AP_DECLARE(ap_filter_t *) ap_add_output_
 
 static APR_INLINE int is_pending_filter(ap_filter_t *f)
 {
-    return APR_RING_NEXT(f, pending) != f;
+    struct ap_filter_private *fp = f->priv;
+    return APR_RING_NEXT(fp, pending) != fp;
 }
 
 static apr_status_t pending_filter_cleanup(void *arg)
 {
     ap_filter_t *f = arg;
+    struct ap_filter_private *fp = f->priv;
 
     if (is_pending_filter(f)) {
-        APR_RING_REMOVE(f, pending);
-        APR_RING_ELEM_INIT(f, pending);
+        APR_RING_REMOVE(fp, pending);
+        APR_RING_ELEM_INIT(fp, pending);
     }
 
-    if (f->bb) {
-        apr_brigade_cleanup(f->bb);
-        put_spare(f->c, f->bb, &f->c->filter_conn_ctx->spare_brigades);
-        f->bb = NULL;
+    if (fp->bb) {
+        ap_release_brigade(f->c, fp->bb);
+        fp->bb = NULL;
     }
 
     return APR_SUCCESS;
@@ -617,14 +655,13 @@ AP_DECLARE(void) ap_remove_input_filter(
 
 AP_DECLARE(void) ap_remove_output_filter(ap_filter_t *f)
 {
+    struct ap_filter_private *fp = f->priv;
 
-    if ((f->bb) && !APR_BRIGADE_EMPTY(f->bb)) {
-        apr_brigade_cleanup(f->bb);
-    }
-
-    if (f->deferred_pool) {
-        apr_pool_destroy(f->deferred_pool);
-        f->deferred_pool = NULL;
+    if (fp->deferred_pool) {
+        AP_DEBUG_ASSERT(fp->bb);
+        apr_brigade_cleanup(fp->bb);
+        apr_pool_destroy(fp->deferred_pool);
+        fp->deferred_pool = NULL;
     }
 
     remove_any_filter(f, f->r ? &f->r->output_filters : NULL,
@@ -833,23 +870,31 @@ AP_DECLARE(int) ap_filter_prepare_brigad
 {
     conn_rec *c = f->c;
     struct ap_filter_conn_ctx *x = get_conn_ctx(c);
-    struct ap_filter_ring **ref, *pendings;
-    ap_filter_t *next, *e;
-    int found = 0;
-
-    if (!f->bb) {
-        f->bb = get_spare(c, x->spare_brigades);
-        if (!f->bb) {
-            f->bb = apr_brigade_create(c->pool, c->bucket_alloc);
-        }
+    struct ap_filter_private *fp = f->priv, *e;
+    struct pending_ring **ref, *pendings;
+    ap_filter_t *next;
+
+    if (is_pending_filter(f)) {
+        return DECLINED;
+    }
+
+    if (!fp->bb) {
+        fp->bb = ap_acquire_brigade(c);
         if (f->r) {
+            /* Take care of request filters that don't remove themselves
+             * from the chain(s), when f->r is being destroyed.
+             */
             apr_pool_cleanup_register(f->r->pool, f,
                                       pending_filter_cleanup,
                                       apr_pool_cleanup_null);
         }
-    }
-    if (is_pending_filter(f)) {
-        return DECLINED;
+        else {
+            /* In fp->bb there may be buckets on fp->deferred_pool, so take
+             * care to always pre_cleanup the former before the latter.
+             */
+            apr_pool_pre_cleanup_register(c->pool, f,
+                                          pending_filter_cleanup);
+        }
     }
 
     if (f->frec->direction == AP_FILTER_INPUT) {
@@ -867,41 +912,39 @@ AP_DECLARE(int) ap_filter_prepare_brigad
      * any, otherwise insert last.
      */
     if (pendings) {
-        for (next = f->next; next && !found; next = next->next) {
+        for (next = f->next; next; next = next->next) {
             for (e = APR_RING_FIRST(pendings);
-                 e != APR_RING_SENTINEL(pendings, ap_filter_t, pending);
+                 e != APR_RING_SENTINEL(pendings, ap_filter_private, pending);
                  e = APR_RING_NEXT(e, pending)) {
-                if (e == next) {
-                    APR_RING_INSERT_BEFORE(e, f, pending);
-                    found = 1;
-                    break;
+                if (e == next->priv) {
+                    APR_RING_INSERT_BEFORE(e, fp, pending);
+                    return OK;
                 }
             }
         }
     }
     else {
         pendings = *ref = apr_palloc(c->pool, sizeof(*pendings));
-        APR_RING_INIT(pendings, ap_filter_t, pending);
+        APR_RING_INIT(pendings, ap_filter_private, pending);
     }
-    if (!found) {
-        APR_RING_INSERT_TAIL(pendings, f, ap_filter_t, pending);
-    }
- 
+    APR_RING_INSERT_TAIL(pendings, fp, ap_filter_private, pending);
     return OK;
 }
 
 AP_DECLARE(apr_status_t) ap_filter_setaside_brigade(ap_filter_t *f,
                                                     apr_bucket_brigade *bb)
 {
+    struct ap_filter_private *fp = f->priv;
+
     ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, f->c,
                   "setaside %s brigade to %s brigade in '%s' output filter",
                   APR_BRIGADE_EMPTY(bb) ? "empty" : "full",
-                  (!f->bb || APR_BRIGADE_EMPTY(f->bb)) ? "empty" : "full",
+                  (!fp->bb || APR_BRIGADE_EMPTY(fp->bb)) ? "empty" : "full",
                   f->frec->name);
 
     if (!APR_BRIGADE_EMPTY(bb)) {
         /*
-         * Set aside the brigade bb within f->bb.
+         * Set aside the brigade bb within fp->bb.
          */
         ap_filter_prepare_brigade(f);
 
@@ -917,24 +960,25 @@ AP_DECLARE(apr_status_t) ap_filter_setas
                     }
                 }
             }
-            APR_BRIGADE_CONCAT(f->bb, bb);
+            APR_BRIGADE_CONCAT(fp->bb, bb);
         }
         else {
-            if (!f->deferred_pool) {
-                apr_pool_create(&f->deferred_pool, f->c->pool);
-                apr_pool_tag(f->deferred_pool, "deferred_pool");
+            if (!fp->deferred_pool) {
+                apr_pool_create(&fp->deferred_pool, f->c->pool);
+                apr_pool_tag(fp->deferred_pool, "deferred_pool");
             }
-            return ap_save_brigade(f, &f->bb, &bb, f->deferred_pool);
+            return ap_save_brigade(f, &fp->bb, &bb, fp->deferred_pool);
         }
 
     }
-    else if (f->deferred_pool) {
+    else if (fp->deferred_pool) {
         /*
          * There are no more requests in the pipeline. We can just clear the
          * pool.
          */
-        apr_brigade_cleanup(f->bb);
-        apr_pool_clear(f->deferred_pool);
+        AP_DEBUG_ASSERT(fp->bb);
+        apr_brigade_cleanup(fp->bb);
+        apr_pool_clear(fp->deferred_pool);
     }
     return APR_SUCCESS;
 }
@@ -946,16 +990,17 @@ AP_DECLARE(apr_status_t) ap_filter_reins
     apr_bucket *bucket, *next;
     apr_size_t bytes_in_brigade, non_file_bytes_in_brigade;
     int eor_buckets_in_brigade, morphing_bucket_in_brigade;
+    struct ap_filter_private *fp = f->priv;
     core_server_config *conf;
  
     ap_log_cerror(APLOG_MARK, APLOG_TRACE6, 0, f->c,
                   "reinstate %s brigade to %s brigade in '%s' output filter",
-                  (!f->bb || APR_BRIGADE_EMPTY(f->bb) ? "empty" : "full"),
+                  (!fp->bb || APR_BRIGADE_EMPTY(fp->bb) ? "empty" : "full"),
                   (APR_BRIGADE_EMPTY(bb) ? "empty" : "full"),
                   f->frec->name);
 
-    if (f->bb) {
-        APR_BRIGADE_PREPEND(bb, f->bb);
+    if (fp->bb) {
+        APR_BRIGADE_PREPEND(bb, fp->bb);
     }
     if (!flush_upto) {
         /* Just prepend all. */
@@ -1115,7 +1160,8 @@ AP_DECLARE(int) ap_filter_should_yield(a
      * from us.
      */
     while (f) {
-        if (f->bb && !APR_BRIGADE_EMPTY(f->bb)) {
+        struct ap_filter_private *fp = f->priv;
+        if (fp->bb && !APR_BRIGADE_EMPTY(fp->bb)) {
             return 1;
         }
         f = f->next;
@@ -1126,32 +1172,32 @@ AP_DECLARE(int) ap_filter_should_yield(a
 AP_DECLARE_NONSTD(int) ap_filter_output_pending(conn_rec *c)
 {
     struct ap_filter_conn_ctx *x = c->filter_conn_ctx;
+    struct ap_filter_private *fp, *prev;
     apr_bucket_brigade *bb;
-    ap_filter_t *f, *prev;
     int rc = DECLINED;
 
     if (!x || !x->pending_output_filters) {
         goto cleanup;
     }
 
-    bb = ap_reuse_brigade_from_pool("ap_fop_bb", c->pool,
-                                    c->bucket_alloc);
-
     /* Flush outer most filters first for ap_filter_should_yield(f->next)
      * to be relevant in the previous ones (e.g. ap_request_core_filter()
      * won't pass its buckets if its next filters yield already).
      */
-    for (f = APR_RING_LAST(x->pending_output_filters);
-         f != APR_RING_SENTINEL(x->pending_output_filters,
-                                ap_filter_t, pending);
-         f = prev) {
+    bb = ap_acquire_brigade(c);
+    for (fp = APR_RING_LAST(x->pending_output_filters);
+         fp != APR_RING_SENTINEL(x->pending_output_filters,
+                                 ap_filter_private, pending);
+         fp = prev) {
         /* If a filter removes itself from the filters stack (when run), it
          * also orphans itself from the ring, so save "prev" here to avoid
          * an infinite loop in this case.
          */
-        prev = APR_RING_PREV(f, pending);
+        prev = APR_RING_PREV(fp, pending);
 
-        if (f->bb && !APR_BRIGADE_EMPTY(f->bb)) {
+        AP_DEBUG_ASSERT(fp->bb);
+        if (!APR_BRIGADE_EMPTY(fp->bb)) {
+            ap_filter_t *f = fp->f;
             apr_status_t rv;
 
             rv = ap_pass_brigade(f, bb);
@@ -1164,12 +1210,13 @@ AP_DECLARE_NONSTD(int) ap_filter_output_
                 break;
             }
 
-            if (f->bb && !APR_BRIGADE_EMPTY(f->bb)) {
+            if (fp->bb && !APR_BRIGADE_EMPTY(fp->bb)) {
                 rc = OK;
                 break;
             }
         }
     }
+    ap_release_brigade(c, bb);
 
 cleanup:
     /* No more flushing, all filters have returned, recycle/unleak dead request
@@ -1183,26 +1230,26 @@ cleanup:
 AP_DECLARE_NONSTD(int) ap_filter_input_pending(conn_rec *c)
 {
     struct ap_filter_conn_ctx *x = c->filter_conn_ctx;
-    ap_filter_t *f;
+    struct ap_filter_private *fp;
 
     if (!x || !x->pending_input_filters) {
         return DECLINED;
     }
 
-    for (f = APR_RING_LAST(x->pending_input_filters);
-         f != APR_RING_SENTINEL(x->pending_input_filters,
-                                ap_filter_t, pending);
-         f = APR_RING_PREV(f, pending)) {
-        if (f->bb) {
-            apr_bucket *e = APR_BRIGADE_FIRST(f->bb);
+    for (fp = APR_RING_LAST(x->pending_input_filters);
+         fp != APR_RING_SENTINEL(x->pending_input_filters,
+                                 ap_filter_private, pending);
+         fp = APR_RING_PREV(fp, pending)) {
+        apr_bucket *e;
 
-            /* if there is a leading non-morphing bucket
-             * in place, then we have data pending
-             */
-            if (e != APR_BRIGADE_SENTINEL(f->bb)
-                    && e->length != (apr_size_t)(-1)) {
-                return OK;
-            }
+        /* if there is a leading non-morphing bucket
+         * in place, then we have data pending
+         */
+        AP_DEBUG_ASSERT(fp->bb);
+        e = APR_BRIGADE_FIRST(fp->bb);
+        if (e != APR_BRIGADE_SENTINEL(fp->bb)
+                && e->length != (apr_size_t)(-1)) {
+            return OK;
         }
     }