diff --git a/modules/proxy/mod_proxy.c b/modules/proxy/mod_proxy.c

index de48735..d13c249 100644

--- a/modules/proxy/mod_proxy.c

+++ b/modules/proxy/mod_proxy.c

@@ -1574,6 +1574,8 @@ static void *create_proxy_dir_config(apr_pool_t *p, char *dummy)

     new->error_override_set = 0;

     new->add_forwarded_headers = 1;

     new->add_forwarded_headers_set = 0;

+    new->forward_100_continue = 1;

+    new->forward_100_continue_set = 0;

     return (void *) new;

 }

@@ -1610,6 +1612,11 @@ static void *merge_proxy_dir_config(apr_pool_t *p, void *basev, void *addv)

         : add->add_forwarded_headers;

     new->add_forwarded_headers_set = add->add_forwarded_headers_set

         || base->add_forwarded_headers_set;

+    new->forward_100_continue =

+        (add->forward_100_continue_set == 0) ? base->forward_100_continue

+                                             : add->forward_100_continue;

+    new->forward_100_continue_set = add->forward_100_continue_set

+                                    || base->forward_100_continue_set;

     return new;

 }

@@ -2110,6 +2117,14 @@ static const char *

     conf->preserve_host_set = 1;

     return NULL;

 }

+static const char *

+   forward_100_continue(cmd_parms *parms, void *dconf, int flag)

+{

+   proxy_dir_conf *conf = dconf;

+   conf->forward_100_continue = flag;

+   conf->forward_100_continue_set = 1;

+   return NULL;

+}

 static const char *

     set_recv_buffer_size(cmd_parms *parms, void *dummy, const char *arg)

@@ -2683,6 +2698,9 @@ static const command_rec proxy_cmds[] =

      "Configure local source IP used for request forward"),

     AP_INIT_FLAG("ProxyAddHeaders", add_proxy_http_headers, NULL, RSRC_CONF|ACCESS_CONF,

      "on if X-Forwarded-* headers should be added or completed"),

+    AP_INIT_FLAG("Proxy100Continue", forward_100_continue, NULL, RSRC_CONF|ACCESS_CONF,

+     "on if 100-Continue should be forwarded to the origin server, off if the "

+     "proxy should handle it by itself"),

     {NULL}

 };

diff --git a/modules/proxy/mod_proxy.h b/modules/proxy/mod_proxy.h

index 3419023..288c5d4 100644

--- a/modules/proxy/mod_proxy.h

+++ b/modules/proxy/mod_proxy.h

@@ -240,6 +240,8 @@ typedef struct {

     /** Named back references */

     apr_array_header_t *refs;

+    unsigned int forward_100_continue:1;

+    unsigned int forward_100_continue_set:1;

 } proxy_dir_conf;

 /* if we interpolate env vars per-request, we'll need a per-request

@@ -380,6 +382,12 @@ do {                             \

 (w)->s->io_buffer_size_set   = (c)->io_buffer_size_set;    \

 } while (0)

+#define PROXY_DO_100_CONTINUE(w, r) \

+((w)->s->ping_timeout_set \

+ && (PROXYREQ_REVERSE == (r)->proxyreq) \

+ && !(apr_table_get((r)->subprocess_env, "force-proxy-request-1.0")) \

+ && ap_request_has_body((r)))

+

 /* use 2 hashes */

 typedef struct {

     unsigned int def;

diff --git a/modules/proxy/mod_proxy_ftp.c b/modules/proxy/mod_proxy_ftp.c

index 8f6f853..8d66b4a 100644

--- a/modules/proxy/mod_proxy_ftp.c

+++ b/modules/proxy/mod_proxy_ftp.c

@@ -1181,12 +1181,10 @@ static int proxy_ftp_handler(request_rec *r, proxy_worker *worker,

         return HTTP_SERVICE_UNAVAILABLE;

     }

-    if (!backend->connection) {

-        status = ap_proxy_connection_create_ex("FTP", backend, r);

-        if (status != OK) {

-            proxy_ftp_cleanup(r, backend);

-            return status;

-        }

+    status = ap_proxy_connection_create_ex("FTP", backend, r);

+    if (status != OK) {

+        proxy_ftp_cleanup(r, backend);

+        return status;

     }

     /* Use old naming */

diff --git a/modules/proxy/mod_proxy_hcheck.c b/modules/proxy/mod_proxy_hcheck.c

index 2783a58..dd8e407 100644

--- a/modules/proxy/mod_proxy_hcheck.c

+++ b/modules/proxy/mod_proxy_hcheck.c

@@ -762,10 +762,8 @@ static apr_status_t hc_check_http(baton_t *baton)

     }

     r = create_request_rec(ptemp, ctx->s, baton->balancer, wctx->method);

-    if (!backend->connection) {

-        if ((status = ap_proxy_connection_create_ex("HCOH", backend, r)) != OK) {

-            return backend_cleanup("HCOH", backend, ctx->s, status);

-        }

+    if ((status = ap_proxy_connection_create_ex("HCOH", backend, r)) != OK) {

+        return backend_cleanup("HCOH", backend, ctx->s, status);

     }

     set_request_connection(r, backend->connection);

diff --git a/modules/proxy/mod_proxy_http.c b/modules/proxy/mod_proxy_http.c

index 56af9a8..f007ad6 100644

--- a/modules/proxy/mod_proxy_http.c

+++ b/modules/proxy/mod_proxy_http.c

@@ -216,8 +216,12 @@ static void add_cl(apr_pool_t *p,

     APR_BRIGADE_INSERT_TAIL(header_brigade, e);

 }

-#define ASCII_CRLF  "\015\012"

-#define ASCII_ZERO  "\060"

+#ifndef CRLF_ASCII

+#define CRLF_ASCII  "\015\012"

+#endif

+#ifndef ZERO_ASCII

+#define ZERO_ASCII  "\060"

+#endif

 static void terminate_headers(apr_bucket_alloc_t *bucket_alloc,

                               apr_bucket_brigade *header_brigade)

@@ -225,304 +229,228 @@ static void terminate_headers(apr_bucket_alloc_t *bucket_alloc,

     apr_bucket *e;

     /* add empty line at the end of the headers */

-    e = apr_bucket_immortal_create(ASCII_CRLF, 2, bucket_alloc);

+    e = apr_bucket_immortal_create(CRLF_ASCII, 2, bucket_alloc);

     APR_BRIGADE_INSERT_TAIL(header_brigade, e);

 }

 #define MAX_MEM_SPOOL 16384

-static int stream_reqbody_chunked(apr_pool_t *p,

-                                           request_rec *r,

-                                           proxy_conn_rec *p_conn,

-                                           conn_rec *origin,

-                                           apr_bucket_brigade *header_brigade,

-                                           apr_bucket_brigade *input_brigade)

-{

-    int seen_eos = 0, rv = OK;

-    apr_size_t hdr_len;

-    apr_off_t bytes;

-    apr_status_t status;

-    apr_bucket_alloc_t *bucket_alloc = r->connection->bucket_alloc;

-    apr_bucket_brigade *bb;

-    apr_bucket *e;

-

-    add_te_chunked(p, bucket_alloc, header_brigade);

-    terminate_headers(bucket_alloc, header_brigade);

+typedef enum {

+    RB_INIT = 0,

+    RB_STREAM_CL,

+    RB_STREAM_CHUNKED,

+    RB_SPOOL_CL

+} rb_methods;

-    while (!APR_BUCKET_IS_EOS(APR_BRIGADE_FIRST(input_brigade)))

-    {

-        char chunk_hdr[20];  /* must be here due to transient bucket. */

+typedef struct {

+    apr_pool_t *p;

+    request_rec *r;

+    proxy_worker *worker;

+    proxy_server_conf *sconf;

-        /* If this brigade contains EOS, either stop or remove it. */

-        if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(input_brigade))) {

-            seen_eos = 1;

-

-            /* We can't pass this EOS to the output_filters. */

-            e = APR_BRIGADE_LAST(input_brigade);

-            apr_bucket_delete(e);

-        }

-

-        apr_brigade_length(input_brigade, 1, &bytes);

+    char server_portstr[32];

+    proxy_conn_rec *backend;

+    conn_rec *origin;

-        hdr_len = apr_snprintf(chunk_hdr, sizeof(chunk_hdr),

-                               "%" APR_UINT64_T_HEX_FMT CRLF,

-                               (apr_uint64_t)bytes);

+    apr_bucket_alloc_t *bucket_alloc;

+    apr_bucket_brigade *header_brigade;

+    apr_bucket_brigade *input_brigade;

+    char *old_cl_val, *old_te_val;

+    apr_off_t cl_val;

-        ap_xlate_proto_to_ascii(chunk_hdr, hdr_len);

-        e = apr_bucket_transient_create(chunk_hdr, hdr_len,

-                                        bucket_alloc);

-        APR_BRIGADE_INSERT_HEAD(input_brigade, e);

+    rb_methods rb_method;

-        /*

-         * Append the end-of-chunk CRLF

-         */

-        e = apr_bucket_immortal_create(ASCII_CRLF, 2, bucket_alloc);

-        APR_BRIGADE_INSERT_TAIL(input_brigade, e);

+    int expecting_100;

+    unsigned int do_100_continue:1,

+                 prefetch_nonblocking:1;

+} proxy_http_req_t;

-        if (header_brigade) {

-            /* we never sent the header brigade, so go ahead and

-             * take care of that now

-             */

-            bb = header_brigade;

-

-            /*

-             * Save input_brigade in bb brigade. (At least) in the SSL case

-             * input_brigade contains transient buckets whose data would get

-             * overwritten during the next call of ap_get_brigade in the loop.

-             * ap_save_brigade ensures these buckets to be set aside.

-             * Calling ap_save_brigade with NULL as filter is OK, because

-             * bb brigade already has been created and does not need to get

-             * created by ap_save_brigade.

-             */

-            status = ap_save_brigade(NULL, &bb, &input_brigade, p);

-            if (status != APR_SUCCESS) {

-                return HTTP_INTERNAL_SERVER_ERROR;

-            }

-

-            header_brigade = NULL;

-        }

-        else {

-            bb = input_brigade;

+/* Read what's in the client pipe. If nonblocking is set and read is EAGAIN,

+ * pass a FLUSH bucket to the backend and read again in blocking mode.

+ */

+static int stream_reqbody_read(proxy_http_req_t *req, apr_bucket_brigade *bb,

+                               int nonblocking)

+{

+    request_rec *r = req->r;

+    proxy_conn_rec *p_conn = req->backend;

+    apr_bucket_alloc_t *bucket_alloc = req->bucket_alloc;

+    apr_read_type_e block = nonblocking ? APR_NONBLOCK_READ : APR_BLOCK_READ;

+    apr_status_t status;

+    int rv;

+

+    for (;;) {

+        status = ap_get_brigade(r->input_filters, bb, AP_MODE_READBYTES,

+                                block, HUGE_STRING_LEN);

+        if (block == APR_BLOCK_READ

+                || (!APR_STATUS_IS_EAGAIN(status)

+                    && (status != APR_SUCCESS || !APR_BRIGADE_EMPTY(bb)))) {

+            break;

         }

-        /* The request is flushed below this loop with chunk EOS header */

-        rv = ap_proxy_pass_brigade(bucket_alloc, r, p_conn, origin, bb, 0);

+        /* Flush and retry (blocking) */

+        apr_brigade_cleanup(bb);

+        rv = ap_proxy_pass_brigade(bucket_alloc, r, p_conn, req->origin, bb, 1);

         if (rv != OK) {

             return rv;

         }

-

-        if (seen_eos) {

-            break;

-        }

-

-        status = ap_get_brigade(r->input_filters, input_brigade,

-                                AP_MODE_READBYTES, APR_BLOCK_READ,

-                                HUGE_STRING_LEN);

-

-        if (status != APR_SUCCESS) {

-            conn_rec *c = r->connection;

-            ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(02608)

-                          "read request body failed to %pI (%s)"

-                          " from %s (%s)", p_conn->addr,

-                          p_conn->hostname ? p_conn->hostname: "",

-                          c->client_ip, c->remote_host ? c->remote_host: "");

-            return ap_map_http_request_error(status, HTTP_BAD_REQUEST);

-        }

+        block = APR_BLOCK_READ;

     }

-    if (header_brigade) {

-        /* we never sent the header brigade because there was no request body;

-         * send it now

-         */

-        bb = header_brigade;

-    }

-    else {

-        if (!APR_BRIGADE_EMPTY(input_brigade)) {

-            /* input brigade still has an EOS which we can't pass to the output_filters. */

-            e = APR_BRIGADE_LAST(input_brigade);

-            AP_DEBUG_ASSERT(APR_BUCKET_IS_EOS(e));

-            apr_bucket_delete(e);

-        }

-        bb = input_brigade;

-    }

-

-    e = apr_bucket_immortal_create(ASCII_ZERO ASCII_CRLF

-                                   /* <trailers> */

-                                   ASCII_CRLF,

-                                   5, bucket_alloc);

-    APR_BRIGADE_INSERT_TAIL(bb, e);

-

-    if (apr_table_get(r->subprocess_env, "proxy-sendextracrlf")) {

-        e = apr_bucket_immortal_create(ASCII_CRLF, 2, bucket_alloc);

-        APR_BRIGADE_INSERT_TAIL(bb, e);

+    if (status != APR_SUCCESS) {

+        conn_rec *c = r->connection;

+        ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(02608)

+                      "read request body failed to %pI (%s)"

+                      " from %s (%s)", p_conn->addr,

+                      p_conn->hostname ? p_conn->hostname: "",

+                      c->client_ip, c->remote_host ? c->remote_host: "");

+        return ap_map_http_request_error(status, HTTP_BAD_REQUEST);

     }

-    /* Now we have headers-only, or the chunk EOS mark; flush it */

-    rv = ap_proxy_pass_brigade(bucket_alloc, r, p_conn, origin, bb, 1);

-    return rv;

+    return OK;

 }

-static int stream_reqbody_cl(apr_pool_t *p,

-                                      request_rec *r,

-                                      proxy_conn_rec *p_conn,

-                                      conn_rec *origin,

-                                      apr_bucket_brigade *header_brigade,

-                                      apr_bucket_brigade *input_brigade,

-                                      char *old_cl_val)

+static int stream_reqbody(proxy_http_req_t *req, rb_methods rb_method)

 {

-    int seen_eos = 0, rv = 0;

-    apr_status_t status = APR_SUCCESS;

-    apr_bucket_alloc_t *bucket_alloc = r->connection->bucket_alloc;

-    apr_bucket_brigade *bb;

+    request_rec *r = req->r;

+    int seen_eos = 0, rv = OK;

+    apr_size_t hdr_len;

+    char chunk_hdr[20];  /* must be here due to transient bucket. */

+    proxy_conn_rec *p_conn = req->backend;

+    apr_bucket_alloc_t *bucket_alloc = req->bucket_alloc;

+    apr_bucket_brigade *header_brigade = req->header_brigade;

+    apr_bucket_brigade *input_brigade = req->input_brigade;

+    apr_off_t bytes, bytes_streamed = 0;

     apr_bucket *e;

-    apr_off_t cl_val = 0;

-    apr_off_t bytes;

-    apr_off_t bytes_streamed = 0;

-

-    if (old_cl_val) {

-        char *endstr;

-        add_cl(p, bucket_alloc, header_brigade, old_cl_val);

-        status = apr_strtoff(&cl_val, old_cl_val, &endstr, 10);

-

-        if (status || *endstr || endstr == old_cl_val || cl_val < 0) {

-            ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(01085)

-                          "could not parse request Content-Length (%s)",

-                          old_cl_val);

-            return HTTP_BAD_REQUEST;

+    do {

+        if (APR_BRIGADE_EMPTY(input_brigade)

+                && APR_BRIGADE_EMPTY(header_brigade)) {

+            rv = stream_reqbody_read(req, input_brigade, 1);

+            if (rv != OK) {

+                return rv;

+            }

         }

-    }

-    terminate_headers(bucket_alloc, header_brigade);

-

-    while (!APR_BUCKET_IS_EOS(APR_BRIGADE_FIRST(input_brigade)))

-    {

-        apr_brigade_length(input_brigade, 1, &bytes);

-        bytes_streamed += bytes;

-

-        /* If this brigade contains EOS, either stop or remove it. */

-        if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(input_brigade))) {

-            seen_eos = 1;

-            /* We can't pass this EOS to the output_filters. */

-            e = APR_BRIGADE_LAST(input_brigade);

-            apr_bucket_delete(e);

+        if (!APR_BRIGADE_EMPTY(input_brigade)) {

+            /* If this brigade contains EOS, either stop or remove it. */

+            if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(input_brigade))) {

+                seen_eos = 1;

-            if (apr_table_get(r->subprocess_env, "proxy-sendextracrlf")) {

-                e = apr_bucket_immortal_create(ASCII_CRLF, 2, bucket_alloc);

-                APR_BRIGADE_INSERT_TAIL(input_brigade, e);

+                /* We can't pass this EOS to the output_filters. */

+                e = APR_BRIGADE_LAST(input_brigade);

+                apr_bucket_delete(e);

             }

-        }

-        /* C-L < bytes streamed?!?

-         * We will error out after the body is completely

-         * consumed, but we can't stream more bytes at the

-         * back end since they would in part be interpreted

-         * as another request!  If nothing is sent, then

-         * just send nothing.

-         *

-         * Prevents HTTP Response Splitting.

-         */

-        if (bytes_streamed > cl_val) {

-            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01086)

-                          "read more bytes of request body than expected "

-                          "(got %" APR_OFF_T_FMT ", expected %" APR_OFF_T_FMT ")",

-                          bytes_streamed, cl_val);

-            return HTTP_INTERNAL_SERVER_ERROR;

-        }

-

-        if (header_brigade) {

-            /* we never sent the header brigade, so go ahead and

-             * take care of that now

-             */

-            bb = header_brigade;

+            apr_brigade_length(input_brigade, 1, &bytes);

+            bytes_streamed += bytes;

-            /*

-             * Save input_brigade in bb brigade. (At least) in the SSL case

-             * input_brigade contains transient buckets whose data would get

-             * overwritten during the next call of ap_get_brigade in the loop.

-             * ap_save_brigade ensures these buckets to be set aside.

-             * Calling ap_save_brigade with NULL as filter is OK, because

-             * bb brigade already has been created and does not need to get

-             * created by ap_save_brigade.

-             */

-            status = ap_save_brigade(NULL, &bb, &input_brigade, p);

-            if (status != APR_SUCCESS) {

+            if (rb_method == RB_STREAM_CHUNKED) {

+                if (bytes) {

+                    /*

+                     * Prepend the size of the chunk

+                     */

+                    hdr_len = apr_snprintf(chunk_hdr, sizeof(chunk_hdr),

+                                           "%" APR_UINT64_T_HEX_FMT CRLF,

+                                           (apr_uint64_t)bytes);

+                    ap_xlate_proto_to_ascii(chunk_hdr, hdr_len);

+                    e = apr_bucket_transient_create(chunk_hdr, hdr_len,

+                                                    bucket_alloc);

+                    APR_BRIGADE_INSERT_HEAD(input_brigade, e);

+

+                    /*

+                     * Append the end-of-chunk CRLF

+                     */

+                    e = apr_bucket_immortal_create(CRLF_ASCII, 2, bucket_alloc);

+                    APR_BRIGADE_INSERT_TAIL(input_brigade, e);

+                }

+                if (seen_eos) {

+                    /*

+                     * Append the tailing 0-size chunk

+                     */

+                    e = apr_bucket_immortal_create(ZERO_ASCII CRLF_ASCII

+                                                   /* <trailers> */

+                                                   CRLF_ASCII,

+                                                   5, bucket_alloc);

+                    APR_BRIGADE_INSERT_TAIL(input_brigade, e);

+                }

+            }

+            else if (bytes_streamed > req->cl_val) {

+                /* C-L < bytes streamed?!?

+                 * We will error out after the body is completely

+                 * consumed, but we can't stream more bytes at the

+                 * back end since they would in part be interpreted

+                 * as another request!  If nothing is sent, then

+                 * just send nothing.

+                 *

+                 * Prevents HTTP Response Splitting.

+                 */

+                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01086)

+                              "read more bytes of request body than expected "

+                              "(got %" APR_OFF_T_FMT ", expected "

+                              "%" APR_OFF_T_FMT ")",

+                              bytes_streamed, req->cl_val);

                 return HTTP_INTERNAL_SERVER_ERROR;

             }

-            header_brigade = NULL;

-        }

-        else {

-            bb = input_brigade;

-        }

-

-        /* Once we hit EOS, we are ready to flush. */

-        rv = ap_proxy_pass_brigade(bucket_alloc, r, p_conn, origin, bb, seen_eos);

-        if (rv != OK) {

-            return rv ;

-        }

-

-        if (seen_eos) {

-            break;

+            if (seen_eos && apr_table_get(r->subprocess_env,

+                                          "proxy-sendextracrlf")) {

+                e = apr_bucket_immortal_create(CRLF_ASCII, 2, bucket_alloc);

+                APR_BRIGADE_INSERT_TAIL(input_brigade, e);

+            }

         }

-        status = ap_get_brigade(r->input_filters, input_brigade,

-                                AP_MODE_READBYTES, APR_BLOCK_READ,

-                                HUGE_STRING_LEN);

+        /* If we never sent the header brigade, go ahead and take care of

+         * that now by prepending it (once only since header_brigade will be

+         * empty afterward).

+         */

+        APR_BRIGADE_PREPEND(input_brigade, header_brigade);

-        if (status != APR_SUCCESS) {

-            conn_rec *c = r->connection;

-            ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(02609)

-                          "read request body failed to %pI (%s)"

-                          " from %s (%s)", p_conn->addr,

-                          p_conn->hostname ? p_conn->hostname: "",

-                          c->client_ip, c->remote_host ? c->remote_host: "");

-            return ap_map_http_request_error(status, HTTP_BAD_REQUEST);

+        /* Flush here on EOS because we won't stream_reqbody_read() again */

+        rv = ap_proxy_pass_brigade(bucket_alloc, r, p_conn, req->origin,

+                                   input_brigade, seen_eos);

+        if (rv != OK) {

+            return rv;

         }

-    }

+    } while (!seen_eos);

-    if (bytes_streamed != cl_val) {

+    if (rb_method == RB_STREAM_CL && bytes_streamed != req->cl_val) {

         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01087)

                       "client %s given Content-Length did not match"

                       " number of body bytes read", r->connection->client_ip);

         return HTTP_BAD_REQUEST;

     }

-    if (header_brigade) {

-        /* we never sent the header brigade since there was no request

-         * body; send it now with the flush flag

-         */

-        bb = header_brigade;

-        return(ap_proxy_pass_brigade(bucket_alloc, r, p_conn, origin, bb, 1));

-    }

-

     return OK;

 }

-static int spool_reqbody_cl(apr_pool_t *p,

-                                     request_rec *r,

-                                     proxy_conn_rec *p_conn,

-                                     conn_rec *origin,

-                                     apr_bucket_brigade *header_brigade,

-                                     apr_bucket_brigade *input_brigade,

-                                     int force_cl)

+static int spool_reqbody_cl(proxy_http_req_t *req, apr_off_t *bytes_spooled)

 {

-    int seen_eos = 0;

-    apr_status_t status;

-    apr_bucket_alloc_t *bucket_alloc = r->connection->bucket_alloc;

+    apr_pool_t *p = req->p;

+    request_rec *r = req->r;

+    int seen_eos = 0, rv = OK;

+    apr_status_t status = APR_SUCCESS;

+    apr_bucket_alloc_t *bucket_alloc = req->bucket_alloc;

+    apr_bucket_brigade *input_brigade = req->input_brigade;

     apr_bucket_brigade *body_brigade;

     apr_bucket *e;

-    apr_off_t bytes, bytes_spooled = 0, fsize = 0;

+    apr_off_t bytes, fsize = 0;

     apr_file_t *tmpfile = NULL;

     apr_off_t limit;

     body_brigade = apr_brigade_create(p, bucket_alloc);

+    *bytes_spooled = 0;

     limit = ap_get_limit_req_body(r);

-    while (!APR_BUCKET_IS_EOS(APR_BRIGADE_FIRST(input_brigade)))

-    {

+    do {

+        if (APR_BRIGADE_EMPTY(input_brigade)) {

+            rv = stream_reqbody_read(req, input_brigade, 0);

+            if (rv != OK) {

+                return rv;

+            }

+        }

+

         /* If this brigade contains EOS, either stop or remove it. */

         if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(input_brigade))) {

             seen_eos = 1;

@@ -534,13 +462,13 @@ static int spool_reqbody_cl(apr_pool_t *p,

         apr_brigade_length(input_brigade, 1, &bytes);

-        if (bytes_spooled + bytes > MAX_MEM_SPOOL) {

+        if (*bytes_spooled + bytes > MAX_MEM_SPOOL) {

             /*

              * LimitRequestBody does not affect Proxy requests (Should it?).

              * Let it take effect if we decide to store the body in a

              * temporary file on disk.

              */

-            if (limit && (bytes_spooled + bytes > limit)) {

+            if (limit && (*bytes_spooled + bytes > limit)) {

                 ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01088)

                               "Request body is larger than the configured "

                               "limit of %" APR_OFF_T_FMT, limit);

@@ -610,69 +538,42 @@ static int spool_reqbody_cl(apr_pool_t *p,

         }

-        bytes_spooled += bytes;

-

-        if (seen_eos) {

-            break;

-        }

-

-        status = ap_get_brigade(r->input_filters, input_brigade,

-                                AP_MODE_READBYTES, APR_BLOCK_READ,

-                                HUGE_STRING_LEN);

-

-        if (status != APR_SUCCESS) {

-            conn_rec *c = r->connection;

-            ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(02610)

-                          "read request body failed to %pI (%s)"

-                          " from %s (%s)", p_conn->addr,

-                          p_conn->hostname ? p_conn->hostname: "",

-                          c->client_ip, c->remote_host ? c->remote_host: "");

-            return ap_map_http_request_error(status, HTTP_BAD_REQUEST);

-        }

-    }

+        *bytes_spooled += bytes;

+    } while (!seen_eos);

-    if (bytes_spooled || force_cl) {

-        add_cl(p, bucket_alloc, header_brigade, apr_off_t_toa(p, bytes_spooled));

-    }

-    terminate_headers(bucket_alloc, header_brigade);

-    APR_BRIGADE_CONCAT(header_brigade, body_brigade);

+    APR_BRIGADE_CONCAT(input_brigade, body_brigade);

     if (tmpfile) {

-        apr_brigade_insert_file(header_brigade, tmpfile, 0, fsize, p);

+        apr_brigade_insert_file(input_brigade, tmpfile, 0, fsize, p);

     }

     if (apr_table_get(r->subprocess_env, "proxy-sendextracrlf")) {

-        e = apr_bucket_immortal_create(ASCII_CRLF, 2, bucket_alloc);

-        APR_BRIGADE_INSERT_TAIL(header_brigade, e);

+        e = apr_bucket_immortal_create(CRLF_ASCII, 2, bucket_alloc);

+        APR_BRIGADE_INSERT_TAIL(input_brigade, e);

     }

-    /* This is all a single brigade, pass with flush flagged */

-    return(ap_proxy_pass_brigade(bucket_alloc, r, p_conn, origin, header_brigade, 1));

+    return OK;

 }

-static

-int ap_proxy_http_request(apr_pool_t *p, request_rec *r,

-                                   proxy_conn_rec *p_conn, proxy_worker *worker,

-                                   proxy_server_conf *conf,

-                                   apr_uri_t *uri,

-                                   char *url, char *server_portstr)

+static int ap_proxy_http_prefetch(proxy_http_req_t *req,

+                                  apr_uri_t *uri, char *url)

 {

+    apr_pool_t *p = req->p;

+    request_rec *r = req->r;

     conn_rec *c = r->connection;

-    apr_bucket_alloc_t *bucket_alloc = c->bucket_alloc;

-    apr_bucket_brigade *header_brigade;

-    apr_bucket_brigade *input_brigade;

+    proxy_conn_rec *p_conn = req->backend;

+    apr_bucket_alloc_t *bucket_alloc = req->bucket_alloc;

+    apr_bucket_brigade *header_brigade = req->header_brigade;

+    apr_bucket_brigade *input_brigade = req->input_brigade;

     apr_bucket_brigade *temp_brigade;

     apr_bucket *e;

     char *buf;

     apr_status_t status;

-    enum rb_methods {RB_INIT, RB_STREAM_CL, RB_STREAM_CHUNKED, RB_SPOOL_CL};

-    enum rb_methods rb_method = RB_INIT;

-    char *old_cl_val = NULL;

-    char *old_te_val = NULL;

     apr_off_t bytes_read = 0;

     apr_off_t bytes;

     int force10, rv;

+    apr_read_type_e block;

     conn_rec *origin = p_conn->connection;

     if (apr_table_get(r->subprocess_env, "force-proxy-request-1.0")) {

-        if (r->expecting_100) {

+        if (req->expecting_100) {

             return HTTP_EXPECTATION_FAILED;

         }

         force10 = 1;

@@ -680,17 +581,14 @@ int ap_proxy_http_request(apr_pool_t *p, request_rec *r,

         force10 = 0;

     }

-    header_brigade = apr_brigade_create(p, bucket_alloc);

     rv = ap_proxy_create_hdrbrgd(p, header_brigade, r, p_conn,

-                                 worker, conf, uri, url, server_portstr,

-                                 &old_cl_val, &old_te_val);

+                                 req->worker, req->sconf,

+                                 uri, url, req->server_portstr,

+                                 &req->old_cl_val, &req->old_te_val);

     if (rv != OK) {

         return rv;

     }