granicus.if.org Git - apache/blob - modules/http/chunk_filter.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * chunk_filter.c --- HTTP/1.1 chunked transfer encoding filter.
  19  */
  20
  21 #include "apr_strings.h"
  22 #include "apr_thread_proc.h"    /* for RLIMIT stuff */
  23
  24 #define APR_WANT_STRFUNC
  25 #include "apr_want.h"
  26
  27 #include "httpd.h"
  28 #include "http_config.h"
  29 #include "http_connection.h"
  30 #include "http_core.h"
  31 #include "http_protocol.h"  /* For index_of_response().  Grump. */
  32 #include "http_request.h"
  33
  34 #include "util_filter.h"
  35 #include "util_ebcdic.h"
  36 #include "ap_mpm.h"
  37 #include "scoreboard.h"
  38
  39 #include "mod_core.h"
  40
  41 /*
  42  * A pointer to this is used to memorize in the filter context that a bad
  43  * gateway error bucket had been seen. It is used as an invented unique pointer.
  44  */
  45 static char bad_gateway_seen;
  46
  47 apr_status_t ap_http_chunk_filter(ap_filter_t *f, apr_bucket_brigade *b)
  48 {
  49 #define ASCII_CRLF  "\015\012"
  50 #define ASCII_ZERO  "\060"
  51     conn_rec *c = f->r->connection;
  52     apr_bucket_brigade *more, *tmp;
  53     apr_bucket *e;
  54     apr_status_t rv;
  55
  56     for (more = tmp = NULL; b; b = more, more = NULL) {
  57         apr_off_t bytes = 0;
  58         apr_bucket *eos = NULL;
  59         apr_bucket *flush = NULL;
  60         /* XXX: chunk_hdr must remain at this scope since it is used in a
  61          *      transient bucket.
  62          */
  63         char chunk_hdr[20]; /* enough space for the snprintf below */
  64
  65
  66         for (e = APR_BRIGADE_FIRST(b);
  67              e != APR_BRIGADE_SENTINEL(b);
  68              e = APR_BUCKET_NEXT(e))
  69         {
  70             if (APR_BUCKET_IS_EOS(e)) {
  71                 /* there shouldn't be anything after the eos */
  72                 eos = e;
  73                 break;
  74             }
  75             if (AP_BUCKET_IS_ERROR(e) &&
  76                 (((ap_bucket_error *)(e->data))->status == HTTP_BAD_GATEWAY ||
  77                  ((ap_bucket_error *)(e->data))->status == HTTP_GATEWAY_TIME_OUT)) {
  78                 /*
  79                  * We had a broken backend. Memorize this in the filter
  80                  * context.
  81                  */
  82                 f->ctx = &bad_gateway_seen;
  83                 continue;
  84             }
  85             if (APR_BUCKET_IS_FLUSH(e)) {
  86                 flush = e;
  87                 if (e != APR_BRIGADE_LAST(b)) {
  88                     more = apr_brigade_split_ex(b, APR_BUCKET_NEXT(e), tmp);
  89                 }
  90                 break;
  91             }
  92             else if (e->length == (apr_size_t)-1) {
  93                 /* unknown amount of data (e.g. a pipe) */
  94                 const char *data;
  95                 apr_size_t len;
  96
  97                 rv = apr_bucket_read(e, &data, &len, APR_BLOCK_READ);
  98                 if (rv != APR_SUCCESS) {
  99                     return rv;
 100                 }
 101                 if (len > 0) {
 102                     /*
 103                      * There may be a new next bucket representing the
 104                      * rest of the data stream on which a read() may
 105                      * block so we pass down what we have so far.
 106                      */
 107                     bytes += len;
 108                     more = apr_brigade_split_ex(b, APR_BUCKET_NEXT(e), tmp);
 109                     break;
 110                 }
 111                 else {
 112                     /* If there was nothing in this bucket then we can
 113                      * safely move on to the next one without pausing
 114                      * to pass down what we have counted up so far.
 115                      */
 116                     continue;
 117                 }
 118             }
 119             else {
 120                 bytes += e->length;
 121             }
 122         }
 123
 124         /*
 125          * XXX: if there aren't very many bytes at this point it may
 126          * be a good idea to set them aside and return for more,
 127          * unless we haven't finished counting this brigade yet.
 128          */
 129         /* if there are content bytes, then wrap them in a chunk */
 130         if (bytes > 0) {
 131             apr_size_t hdr_len;
 132             /*
 133              * Insert the chunk header, specifying the number of bytes in
 134              * the chunk.
 135              */
 136             hdr_len = apr_snprintf(chunk_hdr, sizeof(chunk_hdr),
 137                                    "%" APR_UINT64_T_HEX_FMT CRLF, (apr_uint64_t)bytes);
 138             ap_xlate_proto_to_ascii(chunk_hdr, hdr_len);
 139             e = apr_bucket_transient_create(chunk_hdr, hdr_len,
 140                                             c->bucket_alloc);
 141             APR_BRIGADE_INSERT_HEAD(b, e);
 142
 143             /*
 144              * Insert the end-of-chunk CRLF before an EOS or
 145              * FLUSH bucket, or appended to the brigade
 146              */
 147             e = apr_bucket_immortal_create(ASCII_CRLF, 2, c->bucket_alloc);
 148             if (eos != NULL) {
 149                 APR_BUCKET_INSERT_BEFORE(eos, e);
 150             }
 151             else if (flush != NULL) {
 152                 APR_BUCKET_INSERT_BEFORE(flush, e);
 153             }
 154             else {
 155                 APR_BRIGADE_INSERT_TAIL(b, e);
 156             }
 157         }
 158
 159         /* RFC 2616, Section 3.6.1
 160          *
 161          * If there is an EOS bucket, then prefix it with:
 162          *   1) the last-chunk marker ("0" CRLF)
 163          *   2) the trailer
 164          *   3) the end-of-chunked body CRLF
 165          *
 166          * We only do this if we have not seen an error bucket with
 167          * status HTTP_BAD_GATEWAY. We have memorized an
 168          * error bucket that we had seen in the filter context.
 169          * The error bucket with status HTTP_BAD_GATEWAY indicates that the
 170          * connection to the backend (mod_proxy) broke in the middle of the
 171          * response. In order to signal the client that something went wrong
 172          * we do not create the last-chunk marker and set c->keepalive to
 173          * AP_CONN_CLOSE in the core output filter.
 174          *
 175          * XXX: it would be nice to combine this with the end-of-chunk
 176          * marker above, but this is a bit more straight-forward for
 177          * now.
 178          */
 179         if (eos && !f->ctx) {
 180             /* XXX: (2) trailers ... does not yet exist */
 181             e = apr_bucket_immortal_create(ASCII_ZERO ASCII_CRLF
 182                                            /* <trailers> */
 183                                            ASCII_CRLF, 5, c->bucket_alloc);
 184             APR_BUCKET_INSERT_BEFORE(eos, e);
 185         }
 186
 187         /* pass the brigade to the next filter. */
 188         rv = ap_pass_brigade(f->next, b);
 189         if (rv != APR_SUCCESS || eos != NULL) {
 190             return rv;
 191         }
 192         tmp = b;
 193         apr_brigade_cleanup(tmp);
 194     }
 195     return APR_SUCCESS;
 196 }