/* 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 <assert.h>

#include <stdio.h>

#include <apr_date.h>

#include <apr_lib.h>

#include <apr_strings.h>

#include <httpd.h>

#include <http_core.h>

#include <http_log.h>

#include <http_connection.h>

#include <http_protocol.h>

#include <http_request.h>

#include <util_time.h>

#include "h2_private.h"

#include "h2_headers.h"

#include "h2_from_h1.h"

#include "h2_task.h"

#include "h2_util.h"

/* This routine is called by apr_table_do and merges all instances of

 * the passed field values into a single array that will be further

 * processed by some later routine.  Originally intended to help split

 * and recombine multiple Vary fields, though it is generic to any field

 * consisting of comma/space-separated tokens.

 */

static int uniq_field_values(void *d, const char *key, const char *val)

{

    apr_array_header_t *values;

    char *start;

    char *e;

    char **strpp;

    int  i;

    (void)key;

    values = (apr_array_header_t *)d;

    e = apr_pstrdup(values->pool, val);

    do {

        /* Find a non-empty fieldname */

        while (*e == ',' || apr_isspace(*e)) {

            ++e;

        }

        if (*e == '\0') {

            break;

        }

        start = e;

        while (*e != '\0' && *e != ',' && !apr_isspace(*e)) {

            ++e;

        }

        if (*e != '\0') {

            *e++ = '\0';

        }

        /* Now add it to values if it isn't already represented.

         * Could be replaced by a ap_array_strcasecmp() if we had one.

         */

        for (i = 0, strpp = (char **) values->elts; i < values->nelts;

             ++i, ++strpp) {

            if (*strpp && apr_strnatcasecmp(*strpp, start) == 0) {

                break;

            }

        }

        if (i == values->nelts) {  /* if not found */

            *(char **)apr_array_push(values) = start;

        }

    } while (*e != '\0');

    return 1;

}

/*

 * Since some clients choke violently on multiple Vary fields, or

 * Vary fields with duplicate tokens, combine any multiples and remove

 * any duplicates.

 */

static void fix_vary(request_rec *r)

{

    apr_array_header_t *varies;

    varies = apr_array_make(r->pool, 5, sizeof(char *));

    /* Extract all Vary fields from the headers_out, separate each into

     * its comma-separated fieldname values, and then add them to varies

     * if not already present in the array.

     */

    apr_table_do(uniq_field_values, varies, r->headers_out, "Vary", NULL);

    /* If we found any, replace old Vary fields with unique-ified value */

    if (varies->nelts > 0) {

        apr_table_setn(r->headers_out, "Vary",

                       apr_array_pstrcat(r->pool, varies, ','));

    }

}

static void set_basic_http_header(apr_table_t *headers, request_rec *r,

                                  apr_pool_t *pool)

{

    char *date = NULL;

    const char *proxy_date = NULL;

    const char *server = NULL;

    const char *us = ap_get_server_banner();

    /*

     * keep the set-by-proxy server and date headers, otherwise

     * generate a new server header / date header

     */

    if (r && r->proxyreq != PROXYREQ_NONE) {

        proxy_date = apr_table_get(r->headers_out, "Date");

        if (!proxy_date) {

            /*

             * proxy_date needs to be const. So use date for the creation of

             * our own Date header and pass it over to proxy_date later to

             * avoid a compiler warning.

             */

            date = apr_palloc(pool, APR_RFC822_DATE_LEN);

            ap_recent_rfc822_date(date, r->request_time);

        }

        server = apr_table_get(r->headers_out, "Server");

    }

    else {

        date = apr_palloc(pool, APR_RFC822_DATE_LEN);

        ap_recent_rfc822_date(date, r? r->request_time : apr_time_now());

    }

    apr_table_setn(headers, "Date", proxy_date ? proxy_date : date );

    if (r) {

        apr_table_unset(r->headers_out, "Date");

    }

    if (!server && *us) {

        server = us;

    }

    if (server) {

        apr_table_setn(headers, "Server", server);

        if (r) {

            apr_table_unset(r->headers_out, "Server");

        }

    }

}

static int copy_header(void *ctx, const char *name, const char *value)

{

    apr_table_t *headers = ctx;

    apr_table_add(headers, name, value);

    return 1;

}

static h2_headers *create_response(h2_task *task, request_rec *r)

{

    const char *clheader;

    const char *ctype;

    apr_table_t *headers;

    /*

     * Now that we are ready to send a response, we need to combine the two

     * header field tables into a single table.  If we don't do this, our

     * later attempts to set or unset a given fieldname might be bypassed.

     */

    if (!apr_is_empty_table(r->err_headers_out)) {

        r->headers_out = apr_table_overlay(r->pool, r->err_headers_out,

                                           r->headers_out);

        apr_table_clear(r->err_headers_out);

    }

    /*

     * Remove the 'Vary' header field if the client can't handle it.

     * Since this will have nasty effects on HTTP/1.1 caches, force

     * the response into HTTP/1.0 mode.

     */

    if (apr_table_get(r->subprocess_env, "force-no-vary") != NULL) {

        apr_table_unset(r->headers_out, "Vary");

        r->proto_num = HTTP_VERSION(1,0);

        apr_table_setn(r->subprocess_env, "force-response-1.0", "1");

    }

    else {

        fix_vary(r);

    }

    /*

     * Now remove any ETag response header field if earlier processing

     * says so (such as a 'FileETag None' directive).

     */

    if (apr_table_get(r->notes, "no-etag") != NULL) {

        apr_table_unset(r->headers_out, "ETag");

    }

    /* determine the protocol and whether we should use keepalives. */

    ap_set_keepalive(r);

    if (AP_STATUS_IS_HEADER_ONLY(r->status)) {

        apr_table_unset(r->headers_out, "Transfer-Encoding");

        apr_table_unset(r->headers_out, "Content-Length");

        r->content_type = r->content_encoding = NULL;

        r->content_languages = NULL;

        r->clength = r->chunked = 0;

    }

    else if (r->chunked) {

        apr_table_mergen(r->headers_out, "Transfer-Encoding", "chunked");

        apr_table_unset(r->headers_out, "Content-Length");

    }

    ctype = ap_make_content_type(r, r->content_type);

    if (ctype) {

        apr_table_setn(r->headers_out, "Content-Type", ctype);

    }

    if (r->content_encoding) {

        apr_table_setn(r->headers_out, "Content-Encoding",

                       r->content_encoding);

    }

    if (!apr_is_empty_array(r->content_languages)) {

        unsigned int i;

        char *token;

        char **languages = (char **)(r->content_languages->elts);

        const char *field = apr_table_get(r->headers_out, "Content-Language");

        while (field && (token = ap_get_list_item(r->pool, &field)) != NULL) {

            for (i = 0; i < r->content_languages->nelts; ++i) {

                if (!apr_strnatcasecmp(token, languages[i]))

                    break;

            }

            if (i == r->content_languages->nelts) {

                *((char **) apr_array_push(r->content_languages)) = token;

            }

        }

        field = apr_array_pstrcat(r->pool, r->content_languages, ',');

        apr_table_setn(r->headers_out, "Content-Language", field);

    }

    /*

     * Control cachability for non-cachable responses if not already set by

     * some other part of the server configuration.

     */

    if (r->no_cache && !apr_table_get(r->headers_out, "Expires")) {

        char *date = apr_palloc(r->pool, APR_RFC822_DATE_LEN);

        ap_recent_rfc822_date(date, r->request_time);

        apr_table_add(r->headers_out, "Expires", date);

    }

    /* This is a hack, but I can't find anyway around it.  The idea is that

     * we don't want to send out 0 Content-Lengths if it is a head request.

     * This happens when modules try to outsmart the server, and return

     * if they see a HEAD request.  Apache 1.3 handlers were supposed to

     * just return in that situation, and the core handled the HEAD.  In

     * 2.0, if a handler returns, then the core sends an EOS bucket down

     * the filter stack, and the content-length filter computes a C-L of

     * zero and that gets put in the headers, and we end up sending a

     * zero C-L to the client.  We can't just remove the C-L filter,

     * because well behaved 2.0 handlers will send their data down the stack,

     * and we will compute a real C-L for the head request. RBB

     */

    if (r->header_only

        && (clheader = apr_table_get(r->headers_out, "Content-Length"))

        && !strcmp(clheader, "0")) {

        apr_table_unset(r->headers_out, "Content-Length");

    }

    headers = apr_table_make(r->pool, 10);

    set_basic_http_header(headers, r, r->pool);

    if (r->status == HTTP_NOT_MODIFIED) {

        apr_table_do(copy_header, headers, r->headers_out,

                     "ETag",

                     "Content-Location",

                     "Expires",

                     "Cache-Control",

                     "Vary",

                     "Warning",

                     "WWW-Authenticate",

                     "Proxy-Authenticate",

                     "Set-Cookie",

                     "Set-Cookie2",

                     NULL);

    }

    else {

        apr_table_do(copy_header, headers, r->headers_out, NULL);

    }

    return h2_headers_rcreate(r, r->status, headers, r->pool);

}

typedef enum {

    H2_RP_STATUS_LINE,

    H2_RP_HEADER_LINE,

    H2_RP_DONE

} h2_rp_state_t;

typedef struct h2_response_parser {

    h2_rp_state_t state;

    h2_task *task;

    int http_status;

    apr_array_header_t *hlines;

    apr_bucket_brigade *tmp;

} h2_response_parser;

static apr_status_t parse_header(h2_response_parser *parser, char *line) {

    const char *hline;

    if (line[0] == ' ' || line[0] == '\t') {

        char **plast;

        /* continuation line from the header before this */

        while (line[0] == ' ' || line[0] == '\t') {

            ++line;

        }

        plast = apr_array_pop(parser->hlines);

        if (plast == NULL) {

            /* not well formed */

            return APR_EINVAL;

        }

        hline = apr_psprintf(parser->task->pool, "%s %s", *plast, line);

    }

    else {

        /* new header line */

        hline = apr_pstrdup(parser->task->pool, line);

    }

    APR_ARRAY_PUSH(parser->hlines, const char*) = hline; 

    return APR_SUCCESS;

}

static apr_status_t get_line(h2_response_parser *parser, apr_bucket_brigade *bb, 

                             char *line, apr_size_t len)

{

    h2_task *task = parser->task;

    apr_status_t status;

    if (!parser->tmp) {

        parser->tmp = apr_brigade_create(task->pool, task->c->bucket_alloc);

    }

    status = apr_brigade_split_line(parser->tmp, bb, APR_BLOCK_READ, 

                                    HUGE_STRING_LEN);

    if (status == APR_SUCCESS) {

        --len;

        status = apr_brigade_flatten(parser->tmp, line, &len;;

        if (status == APR_SUCCESS) {

            /* we assume a non-0 containing line and remove trailing crlf. */

            line[len] = '\0';

            if (len >= 2 && !strcmp(H2_CRLF, line + len - 2)) {

                len -= 2;

                line[len] = '\0';

                apr_brigade_cleanup(parser->tmp);

                ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, task->c,

                              "h2_task(%s): read response line: %s", 

                              task->id, line);

            }

            else {

                /* this does not look like a complete line yet */

                ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, task->c,

                              "h2_task(%s): read response, incomplete line: %s", 

                              task->id, line);

                return APR_EAGAIN;

            }

        }

    }

    apr_brigade_cleanup(parser->tmp);

    return status;

}

static apr_table_t *make_table(h2_response_parser *parser)

{

    h2_task *task = parser->task;

    apr_array_header_t *hlines = parser->hlines;

    if (hlines) {

        apr_table_t *headers = apr_table_make(task->pool, hlines->nelts);        

        int i;

        for (i = 0; i < hlines->nelts; ++i) {

            char *hline = ((char **)hlines->elts)[i];

            char *sep = ap_strchr(hline, ':');

            if (!sep) {

                ap_log_cerror(APLOG_MARK, APLOG_WARNING, APR_EINVAL, task->c,

                              APLOGNO(02955) "h2_task(%s): invalid header[%d] '%s'",

                              task->id, i, (char*)hline);

                /* not valid format, abort */

                return NULL;

            }

            (*sep++) = '\0';

            while (*sep == ' ' || *sep == '\t') {

                ++sep;

            }

            if (!h2_util_ignore_header(hline)) {

                apr_table_merge(headers, hline, sep);

            }

        }

        return headers;

    }

    else {

        return apr_table_make(task->pool, 0);        

    }

}

static apr_status_t pass_response(h2_task *task, ap_filter_t *f, 

                                  h2_response_parser *parser) 

{

    apr_bucket *b;

    apr_status_t status;

    h2_headers *response = h2_headers_create(parser->http_status, 

                                             make_table(parser),

                                             NULL, 0, task->pool);

    apr_brigade_cleanup(parser->tmp);

    b = h2_bucket_headers_create(task->c->bucket_alloc, response);

    APR_BRIGADE_INSERT_TAIL(parser->tmp, b);

    b = apr_bucket_flush_create(task->c->bucket_alloc);

    APR_BRIGADE_INSERT_TAIL(parser->tmp, b);                      

    status = ap_pass_brigade(f->next, parser->tmp);

    apr_brigade_cleanup(parser->tmp);

    /* reset parser for possible next response */

    parser->state = H2_RP_STATUS_LINE;

    apr_array_clear(parser->hlines);

    if (response->status >= 200) {

        task->output.sent_response = 1;

    }

    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, task->c, 

                  APLOGNO(03197) "h2_task(%s): passed response %d", 

                  task->id, response->status);

    return status;

}

static apr_status_t parse_status(h2_task *task, char *line)

{

    h2_response_parser *parser = task->output.rparser;

    int sindex = (apr_date_checkmask(line, "HTTP/#.# ###*")? 9 : 

                  (apr_date_checkmask(line, "HTTP/# ###*")? 7 : 0));

    if (sindex > 0) {

        int k = sindex + 3;

        char keepchar = line[k];

        line[k] = '\0';

        parser->http_status = atoi(&line[sindex]);

        line[k] = keepchar;

        parser->state = H2_RP_HEADER_LINE;

        return APR_SUCCESS;

    }

    /* Seems like there is garbage on the connection. May be a leftover

     * from a previous proxy request. 

     * This should only happen if the H2_RESPONSE filter is not yet in 

     * place (post_read_request has not been reached and the handler wants

     * to write something. Probably just the interim response we are

     * waiting for. But if there is other data hanging around before

     * that, this needs to fail. */

    ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, task->c, APLOGNO(03467)

                  "h2_task(%s): unable to parse status line: %s", 

                  task->id, line);

    return APR_EINVAL;

}

apr_status_t h2_from_h1_parse_response(h2_task *task, ap_filter_t *f, 

                                       apr_bucket_brigade *bb)

{

    h2_response_parser *parser = task->output.rparser;

    char line[HUGE_STRING_LEN];

    apr_status_t status = APR_SUCCESS;

    if (!parser) {

        parser = apr_pcalloc(task->pool, sizeof(*parser));

        parser->task = task;

        parser->state = H2_RP_STATUS_LINE;

        parser->hlines = apr_array_make(task->pool, 10, sizeof(char *));

        task->output.rparser = parser;

    }

    while (!APR_BRIGADE_EMPTY(bb) && status == APR_SUCCESS) {

        switch (parser->state) {

            case H2_RP_STATUS_LINE:

            case H2_RP_HEADER_LINE:

                status = get_line(parser, bb, line, sizeof(line));

                if (status == APR_EAGAIN) {

                    /* need more data */

                    return APR_SUCCESS;

                }

                else if (status != APR_SUCCESS) {

                    return status;

                }

                if (parser->state == H2_RP_STATUS_LINE) {

                    /* instead of parsing, just take it directly */

                    status = parse_status(task, line);

                }

                else if (line[0] == '\0') {

                    /* end of headers, pass response onward */

                    ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,

                                  "h2_task(%s): end of response", task->id);

                    return pass_response(task, f, parser);

                }

                else {

                    ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,

                                  "h2_task(%s): response header %s", task->id, line);

                    status = parse_header(parser, line);

                }

                break;

            default:

                return status;

        }

    }

    return status;

}

apr_status_t h2_filter_headers_out(ap_filter_t *f, apr_bucket_brigade *bb)

{

    h2_task *task = f->ctx;

    request_rec *r = f->r;

    apr_bucket *b, *bresp, *body_bucket = NULL, *next;

    ap_bucket_error *eb = NULL;

    h2_headers *response = NULL;

    int headers_passing = 0;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,

                  "h2_task(%s): output_filter called", task->id);

    if (!task->output.sent_response && !f->c->aborted) {

        /* check, if we need to send the response now. Until we actually

         * see a DATA bucket or some EOS/EOR, we do not do so. */

        for (b = APR_BRIGADE_FIRST(bb);

             b != APR_BRIGADE_SENTINEL(bb);

             b = APR_BUCKET_NEXT(b))

        {

            if (AP_BUCKET_IS_ERROR(b) && !eb) {

                eb = b->data;

            }

            else if (AP_BUCKET_IS_EOC(b)) {

                /* If we see an EOC bucket it is a signal that we should get out

                 * of the way doing nothing.

                 */

                ap_remove_output_filter(f);

                ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, f->c,

                              "h2_task(%s): eoc bucket passed", task->id);

                return ap_pass_brigade(f->next, bb);

            }

            else if (H2_BUCKET_IS_HEADERS(b)) {

                headers_passing = 1;

            }

            else if (!APR_BUCKET_IS_FLUSH(b)) { 

                body_bucket = b;

                break;

            }

        }

        if (eb) {

            int st = eb->status;

            ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, f->c, APLOGNO(03047)

                          "h2_task(%s): err bucket status=%d", task->id, st);

            /* throw everything away and replace it with the error response

             * generated by ap_die() */

            apr_brigade_cleanup(bb);

            ap_die(st, r);

            return AP_FILTER_ERROR;

        }

        if (body_bucket || !headers_passing) {

            /* time to insert the response bucket before the body or if

             * no h2_headers is passed, e.g. the response is empty */

            response = create_response(task, r);

            if (response == NULL) {

                ap_log_cerror(APLOG_MARK, APLOG_NOTICE, 0, f->c, APLOGNO(03048)

                              "h2_task(%s): unable to create response", task->id);

                return APR_ENOMEM;

            }

            bresp = h2_bucket_headers_create(f->c->bucket_alloc, response);

            if (body_bucket) {

                APR_BUCKET_INSERT_BEFORE(body_bucket, bresp);

            }

            else {

                APR_BRIGADE_INSERT_HEAD(bb, bresp);

            }

            task->output.sent_response = 1;

            r->sent_bodyct = 1;

        }

    }

    if (r->header_only) {

        ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,

                      "h2_task(%s): header_only, cleanup output brigade", 

                      task->id);

        b = body_bucket? body_bucket : APR_BRIGADE_FIRST(bb);

        while (b != APR_BRIGADE_SENTINEL(bb)) {

            next = APR_BUCKET_NEXT(b);

            if (APR_BUCKET_IS_EOS(b) || AP_BUCKET_IS_EOR(b)) {

                break;

            } 

            APR_BUCKET_REMOVE(b);

            apr_bucket_destroy(b);

            b = next;

        }

    }

    else if (task->output.sent_response) {

        /* lets get out of the way, our task is done */

        ap_remove_output_filter(f);

    }

    return ap_pass_brigade(f->next, bb);

}

static void make_chunk(h2_task *task, apr_bucket_brigade *bb, 

                       apr_bucket *first, apr_off_t chunk_len, 

                       apr_bucket *tail)

{

    /* Surround the buckets [first, tail[ with new buckets carrying the

     * HTTP/1.1 chunked encoding format. If tail is NULL, the chunk extends

     * to the end of the brigade. */

    char buffer[128];

    apr_bucket *c;

    int len;

    len = apr_snprintf(buffer, H2_ALEN(buffer), 

                       "%"APR_UINT64_T_HEX_FMT"\r\n", (apr_uint64_t)chunk_len);

    c = apr_bucket_heap_create(buffer, len, NULL, bb->bucket_alloc);

    APR_BUCKET_INSERT_BEFORE(first, c);

    c = apr_bucket_heap_create("\r\n", 2, NULL, bb->bucket_alloc);

    if (tail) {

        APR_BUCKET_INSERT_BEFORE(tail, c);

    }

    else {

        APR_BRIGADE_INSERT_TAIL(bb, c);

    }

    task->input.chunked_total += chunk_len;

    ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, task->c,

                  "h2_task(%s): added chunk %ld, total %ld", 

                  task->id, (long)chunk_len, (long)task->input.chunked_total);

}

static int ser_header(void *ctx, const char *name, const char *value) 

{

    apr_bucket_brigade *bb = ctx;

    apr_brigade_printf(bb, NULL, NULL, "%s: %s\r\n", name, value);

    return 1;

}

static apr_status_t read_and_chunk(ap_filter_t *f, h2_task *task,

                                   apr_read_type_e block) {

    request_rec *r = f->r;

    apr_status_t status = APR_SUCCESS;

    apr_bucket_brigade *bb = task->input.bbchunk;

    if (!bb) {

        bb = apr_brigade_create(r->pool, f->c->bucket_alloc);

        task->input.bbchunk = bb;

    }

    if (APR_BRIGADE_EMPTY(bb)) {

        apr_bucket *b, *next, *first_data = NULL;

        apr_bucket_brigade *tmp;

        apr_off_t bblen = 0;

        /* get more data from the lower layer filters. Always do this

         * in larger pieces, since we handle the read modes ourself. */

        status = ap_get_brigade(f->next, bb, 

                                AP_MODE_READBYTES, block, 32*1024);

        if (status == APR_EOF) {

            if (!task->input.eos) {

                status = apr_brigade_puts(bb, NULL, NULL, "0\r\n\r\n");

                task->input.eos = 1;

                return APR_SUCCESS;

            }

            ap_remove_input_filter(f);

            return status;

        }

        else if (status != APR_SUCCESS) {

            return status;

        }

        for (b = APR_BRIGADE_FIRST(bb); 

             b != APR_BRIGADE_SENTINEL(bb) && !task->input.eos; 

             b = next) {

            next = APR_BUCKET_NEXT(b);

            if (APR_BUCKET_IS_METADATA(b)) {

                if (first_data) {

                    make_chunk(task, bb, first_data, bblen, b);

                    first_data = NULL;

                }

                if (H2_BUCKET_IS_HEADERS(b)) {

                    h2_headers *headers = h2_bucket_headers_get(b);

                    ap_assert(headers);

                    ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,

                                  "h2_task(%s): receiving trailers", task->id);

                    tmp = apr_brigade_split_ex(bb, b, NULL);

                    if (!apr_is_empty_table(headers->headers)) {

                        status = apr_brigade_puts(bb, NULL, NULL, "0\r\n");

                        apr_table_do(ser_header, bb, headers->headers, NULL);

                        status = apr_brigade_puts(bb, NULL, NULL, "\r\n");

                    }

                    else {

                        status = apr_brigade_puts(bb, NULL, NULL, "0\r\n\r\n");

                    }

                    r->trailers_in = apr_table_clone(r->pool, headers->headers);

                    APR_BUCKET_REMOVE(b);

                    apr_bucket_destroy(b);

                    APR_BRIGADE_CONCAT(bb, tmp);

                    apr_brigade_destroy(tmp);

                    task->input.eos = 1;

                }

                else if (APR_BUCKET_IS_EOS(b)) {

                    tmp = apr_brigade_split_ex(bb, b, NULL);

                    status = apr_brigade_puts(bb, NULL, NULL, "0\r\n\r\n");

                    APR_BRIGADE_CONCAT(bb, tmp);

                    apr_brigade_destroy(tmp);

                    task->input.eos = 1;

                }

            }

            else if (b->length == 0) {

                APR_BUCKET_REMOVE(b);

                apr_bucket_destroy(b);

            } 

            else {

                if (!first_data) {

                    first_data = b;

                    bblen = 0;

                }

                bblen += b->length;

            }    

        }

        if (first_data) {

            make_chunk(task, bb, first_data, bblen, NULL);

        }            

    }

    return status;

}

apr_status_t h2_filter_request_in(ap_filter_t* f,

                                  apr_bucket_brigade* bb,

                                  ap_input_mode_t mode,

                                  apr_read_type_e block,

                                  apr_off_t readbytes)

{

    h2_task *task = f->ctx;

    request_rec *r = f->r;

    apr_status_t status = APR_SUCCESS;

    apr_bucket *b, *next;

    core_server_config *conf =

        (core_server_config *) ap_get_module_config(r->server->module_config,

                                                    &core_module);

    ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, f->r,

                  "h2_task(%s): request filter, exp=%d", task->id, r->expecting_100);

    if (!task->request->chunked) {

        status = ap_get_brigade(f->next, bb, mode, block, readbytes);

        /* pipe data through, just take care of trailers */

        for (b = APR_BRIGADE_FIRST(bb); 

             b != APR_BRIGADE_SENTINEL(bb); b = next) {

            next = APR_BUCKET_NEXT(b);

            if (H2_BUCKET_IS_HEADERS(b)) {

                h2_headers *headers = h2_bucket_headers_get(b);

                ap_assert(headers);

                ap_log_rerror(APLOG_MARK, APLOG_TRACE2, 0, r,

                              "h2_task(%s): receiving trailers", task->id);

                r->trailers_in = headers->headers;

                if (conf && conf->merge_trailers == AP_MERGE_TRAILERS_ENABLE) {

                    r->headers_in = apr_table_overlay(r->pool, r->headers_in,

                                                      r->trailers_in);                    

                }

                APR_BUCKET_REMOVE(b);

                apr_bucket_destroy(b);

                ap_remove_input_filter(f);

                if (headers->raw_bytes && h2_task_logio_add_bytes_in) {

                    h2_task_logio_add_bytes_in(task->c, headers->raw_bytes);

                }

                break;

            }

        }

        return status;

    }

    /* Things are more complicated. The standard HTTP input filter, which

     * does a lot what we do not want to duplicate, also cares about chunked

     * transfer encoding and trailers.

     * We need to simulate chunked encoding for it to be happy.

     */

    if ((status = read_and_chunk(f, task, block)) != APR_SUCCESS) {

        return status;

    }

    if (mode == AP_MODE_EXHAUSTIVE) {

        /* return all we have */

        APR_BRIGADE_CONCAT(bb, task->input.bbchunk);

    }

    else if (mode == AP_MODE_READBYTES) {

        status = h2_brigade_concat_length(bb, task->input.bbchunk, readbytes);

    }

    else if (mode == AP_MODE_SPECULATIVE) {

        status = h2_brigade_copy_length(bb, task->input.bbchunk, readbytes);

    }

    else if (mode == AP_MODE_GETLINE) {

        /* we are reading a single LF line, e.g. the HTTP headers. 

         * this has the nasty side effect to split the bucket, even

         * though it ends with CRLF and creates a 0 length bucket */

        status = apr_brigade_split_line(bb, task->input.bbchunk, block, 

                                        HUGE_STRING_LEN);

        if (APLOGctrace1(f->c)) {

            char buffer[1024];

            apr_size_t len = sizeof(buffer)-1;

            apr_brigade_flatten(bb, buffer, &len;;

            buffer[len] = 0;

            ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, f->c,

                          "h2_task(%s): getline: %s",

                          task->id, buffer);

        }

    }

    else {

        /* Hmm, well. There is mode AP_MODE_EATCRLF, but we chose not

         * to support it. Seems to work. */

        ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_ENOTIMPL, f->c,

                      APLOGNO(02942) 

                      "h2_task, unsupported READ mode %d", mode);

        status = APR_ENOTIMPL;

    }

    h2_util_bb_log(f->c, task->stream_id, APLOG_TRACE2, "forwarding input", bb);

    return status;

}

apr_status_t h2_filter_trailers_out(ap_filter_t *f, apr_bucket_brigade *bb)

{

    h2_task *task = f->ctx;

    request_rec *r = f->r;

    apr_bucket *b, *e;

    if (task && r) {

        /* Detect the EOS/EOR bucket and forward any trailers that may have

         * been set to our h2_headers.

         */

        for (b = APR_BRIGADE_FIRST(bb);

             b != APR_BRIGADE_SENTINEL(bb);

             b = APR_BUCKET_NEXT(b))

        {

            if ((APR_BUCKET_IS_EOS(b) || AP_BUCKET_IS_EOR(b))

                && r->trailers_out && !apr_is_empty_table(r->trailers_out)) {

                h2_headers *headers;

                apr_table_t *trailers;

                ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, f->c, APLOGNO(03049)

                              "h2_task(%s): sending trailers", task->id);

                trailers = apr_table_clone(r->pool, r->trailers_out);

                headers = h2_headers_rcreate(r, HTTP_OK, trailers, r->pool);

                e = h2_bucket_headers_create(bb->bucket_alloc, headers);

                APR_BUCKET_INSERT_BEFORE(b, e);

                apr_table_clear(r->trailers_out);

                ap_remove_output_filter(f);

                break;

            }

        }     

    }

    return ap_pass_brigade(f->next, bb);

}