granicus.if.org Git - apache/blob - server/protocol.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  * protocol.c --- routines which directly communicate with the client.
  19  *
  20  * Code originally by Rob McCool; much redone by Robert S. Thau
  21  * and the Apache Software Foundation.
  22  */
  23
  24 #include "apr.h"
  25 #include "apr_strings.h"
  26 #include "apr_buckets.h"
  27 #include "apr_lib.h"
  28 #include "apr_signal.h"
  29 #include "apr_strmatch.h"
  30
  31 #define APR_WANT_STDIO          /* for sscanf */
  32 #define APR_WANT_STRFUNC
  33 #define APR_WANT_MEMFUNC
  34 #include "apr_want.h"
  35
  36 #include "util_filter.h"
  37 #include "ap_config.h"
  38 #include "httpd.h"
  39 #include "http_config.h"
  40 #include "http_core.h"
  41 #include "http_protocol.h"
  42 #include "http_main.h"
  43 #include "http_request.h"
  44 #include "http_vhost.h"
  45 #include "http_log.h"           /* For errors detected in basic auth common
  46                                  * support code... */
  47 #include "mod_core.h"
  48 #include "util_charset.h"
  49 #include "util_ebcdic.h"
  50 #include "scoreboard.h"
  51
  52 #if APR_HAVE_STDARG_H
  53 #include <stdarg.h>
  54 #endif
  55 #if APR_HAVE_UNISTD_H
  56 #include <unistd.h>
  57 #endif
  58
  59 /* we know core's module_index is 0 */
  60 #undef APLOG_MODULE_INDEX
  61 #define APLOG_MODULE_INDEX AP_CORE_MODULE_INDEX
  62
  63 APR_HOOK_STRUCT(
  64     APR_HOOK_LINK(pre_read_request)
  65     APR_HOOK_LINK(post_read_request)
  66     APR_HOOK_LINK(log_transaction)
  67     APR_HOOK_LINK(http_scheme)
  68     APR_HOOK_LINK(default_port)
  69     APR_HOOK_LINK(note_auth_failure)
  70     APR_HOOK_LINK(protocol_propose)
  71     APR_HOOK_LINK(protocol_switch)
  72     APR_HOOK_LINK(protocol_get)
  73 )
  74
  75 AP_DECLARE_DATA ap_filter_rec_t *ap_old_write_func = NULL;
  76
  77
  78 /* Patterns to match in ap_make_content_type() */
  79 static const char *needcset[] = {
  80     "text/plain",
  81     "text/html",
  82     NULL
  83 };
  84 static const apr_strmatch_pattern **needcset_patterns;
  85 static const apr_strmatch_pattern *charset_pattern;
  86
  87 AP_DECLARE(void) ap_setup_make_content_type(apr_pool_t *pool)
  88 {
  89     int i;
  90     for (i = 0; needcset[i]; i++) {
  91         continue;
  92     }
  93     needcset_patterns = (const apr_strmatch_pattern **)
  94         apr_palloc(pool, (i + 1) * sizeof(apr_strmatch_pattern *));
  95     for (i = 0; needcset[i]; i++) {
  96         needcset_patterns[i] = apr_strmatch_precompile(pool, needcset[i], 0);
  97     }
  98     needcset_patterns[i] = NULL;
  99     charset_pattern = apr_strmatch_precompile(pool, "charset=", 0);
 100 }
 101
 102 /*
 103  * Builds the content-type that should be sent to the client from the
 104  * content-type specified.  The following rules are followed:
 105  *    - if type is NULL or "", return NULL (do not set content-type).
 106  *    - if charset adding is disabled, stop processing and return type.
 107  *    - then, if there are no parameters on type, add the default charset
 108  *    - return type
 109  */
 110 AP_DECLARE(const char *)ap_make_content_type(request_rec *r, const char *type)
 111 {
 112     const apr_strmatch_pattern **pcset;
 113     core_dir_config *conf =
 114         (core_dir_config *)ap_get_core_module_config(r->per_dir_config);
 115     core_request_config *request_conf;
 116     apr_size_t type_len;
 117
 118     if (!type || *type == '\0') {
 119         return NULL;
 120     }
 121
 122     if (conf->add_default_charset != ADD_DEFAULT_CHARSET_ON) {
 123         return type;
 124     }
 125
 126     request_conf = ap_get_core_module_config(r->request_config);
 127     if (request_conf->suppress_charset) {
 128         return type;
 129     }
 130
 131     type_len = strlen(type);
 132
 133     if (apr_strmatch(charset_pattern, type, type_len) != NULL) {
 134         /* already has parameter, do nothing */
 135         /* XXX we don't check the validity */
 136         ;
 137     }
 138     else {
 139         /* see if it makes sense to add the charset. At present,
 140          * we only add it if the Content-type is one of needcset[]
 141          */
 142         for (pcset = needcset_patterns; *pcset ; pcset++) {
 143             if (apr_strmatch(*pcset, type, type_len) != NULL) {
 144                 struct iovec concat[3];
 145                 concat[0].iov_base = (void *)type;
 146                 concat[0].iov_len = type_len;
 147                 concat[1].iov_base = (void *)"; charset=";
 148                 concat[1].iov_len = sizeof("; charset=") - 1;
 149                 concat[2].iov_base = (void *)(conf->add_default_charset_name);
 150                 concat[2].iov_len = strlen(conf->add_default_charset_name);
 151                 type = apr_pstrcatv(r->pool, concat, 3, NULL);
 152                 break;
 153             }
 154         }
 155     }
 156
 157     return type;
 158 }
 159
 160 AP_DECLARE(void) ap_set_content_length(request_rec *r, apr_off_t clength)
 161 {
 162     r->clength = clength;
 163     apr_table_setn(r->headers_out, "Content-Length",
 164                    apr_off_t_toa(r->pool, clength));
 165 }
 166
 167 /*
 168  * Return the latest rational time from a request/mtime (modification time)
 169  * pair.  We return the mtime unless it's in the future, in which case we
 170  * return the current time.  We use the request time as a reference in order
 171  * to limit the number of calls to time().  We don't check for futurosity
 172  * unless the mtime is at least as new as the reference.
 173  */
 174 AP_DECLARE(apr_time_t) ap_rationalize_mtime(request_rec *r, apr_time_t mtime)
 175 {
 176     apr_time_t now;
 177
 178     /* For all static responses, it's almost certain that the file was
 179      * last modified before the beginning of the request.  So there's
 180      * no reason to call time(NULL) again.  But if the response has been
 181      * created on demand, then it might be newer than the time the request
 182      * started.  In this event we really have to call time(NULL) again
 183      * so that we can give the clients the most accurate Last-Modified.  If we
 184      * were given a time in the future, we return the current time - the
 185      * Last-Modified can't be in the future.
 186      */
 187     now = (mtime < r->request_time) ? r->request_time : apr_time_now();
 188     return (mtime > now) ? now : mtime;
 189 }
 190
 191 /* Get a line of protocol input, including any continuation lines
 192  * caused by MIME folding (or broken clients) if fold != 0, and place it
 193  * in the buffer s, of size n bytes, without the ending newline.
 194  *
 195  * Pulls from r->proto_input_filters instead of r->input_filters for
 196  * stricter protocol adherence and better input filter behavior during
 197  * chunked trailer processing (for http).
 198  *
 199  * If s is NULL, ap_rgetline_core will allocate necessary memory from r->pool.
 200  *
 201  * Returns APR_SUCCESS if there are no problems and sets *read to be
 202  * the full length of s.
 203  *
 204  * APR_ENOSPC is returned if there is not enough buffer space.
 205  * Other errors may be returned on other errors.
 206  *
 207  * The LF is *not* returned in the buffer.  Therefore, a *read of 0
 208  * indicates that an empty line was read.
 209  *
 210  * Notes: Because the buffer uses 1 char for NUL, the most we can return is
 211  *        (n - 1) actual characters.
 212  *
 213  *        If no LF is detected on the last line due to a dropped connection
 214  *        or a full buffer, that's considered an error.
 215  */
 216 AP_DECLARE(apr_status_t) ap_rgetline_core(char **s, apr_size_t n,
 217                                           apr_size_t *read, request_rec *r,
 218                                           int fold, apr_bucket_brigade *bb)
 219 {
 220     apr_status_t rv;
 221     apr_bucket *e;
 222     apr_size_t bytes_handled = 0, current_alloc = 0;
 223     char *pos, *last_char = *s;
 224     int do_alloc = (*s == NULL), saw_eos = 0;
 225
 226     /*
 227      * Initialize last_char as otherwise a random value will be compared
 228      * against APR_ASCII_LF at the end of the loop if bb only contains
 229      * zero-length buckets.
 230      */
 231     if (last_char)
 232         *last_char = '\0';
 233
 234     for (;;) {
 235         apr_brigade_cleanup(bb);
 236         rv = ap_get_brigade(r->proto_input_filters, bb, AP_MODE_GETLINE,
 237                             APR_BLOCK_READ, 0);
 238         if (rv != APR_SUCCESS) {
 239             return rv;
 240         }
 241
 242         /* Something horribly wrong happened.  Someone didn't block!
 243          * (this also happens at the end of each keepalive connection)
 244          */
 245         if (APR_BRIGADE_EMPTY(bb)) {
 246             return APR_EGENERAL;
 247         }
 248
 249         for (e = APR_BRIGADE_FIRST(bb);
 250              e != APR_BRIGADE_SENTINEL(bb);
 251              e = APR_BUCKET_NEXT(e))
 252         {
 253             const char *str;
 254             apr_size_t len;
 255
 256             /* If we see an EOS, don't bother doing anything more. */
 257             if (APR_BUCKET_IS_EOS(e)) {
 258                 saw_eos = 1;
 259                 break;
 260             }
 261
 262             rv = apr_bucket_read(e, &str, &len, APR_BLOCK_READ);
 263             if (rv != APR_SUCCESS) {
 264                 return rv;
 265             }
 266
 267             if (len == 0) {
 268                 /* no use attempting a zero-byte alloc (hurts when
 269                  * using --with-efence --enable-pool-debug) or
 270                  * doing any of the other logic either
 271                  */
 272                 continue;
 273             }
 274
 275             /* Would this overrun our buffer?  If so, we'll die. */
 276             if (n < bytes_handled + len) {
 277                 *read = bytes_handled;
 278                 if (*s) {
 279                     /* ensure this string is NUL terminated */
 280                     if (bytes_handled > 0) {
 281                         (*s)[bytes_handled-1] = '\0';
 282                     }
 283                     else {
 284                         (*s)[0] = '\0';
 285                     }
 286                 }
 287                 return APR_ENOSPC;
 288             }
 289
 290             /* Do we have to handle the allocation ourselves? */
 291             if (do_alloc) {
 292                 /* We'll assume the common case where one bucket is enough. */
 293                 if (!*s) {
 294                     current_alloc = len;
 295                     *s = apr_palloc(r->pool, current_alloc);
 296                 }
 297                 else if (bytes_handled + len > current_alloc) {
 298                     /* Increase the buffer size */
 299                     apr_size_t new_size = current_alloc * 2;
 300                     char *new_buffer;
 301
 302                     if (bytes_handled + len > new_size) {
 303                         new_size = (bytes_handled + len) * 2;
 304                     }
 305
 306                     new_buffer = apr_palloc(r->pool, new_size);
 307
 308                     /* Copy what we already had. */
 309                     memcpy(new_buffer, *s, bytes_handled);
 310                     current_alloc = new_size;
 311                     *s = new_buffer;
 312                 }
 313             }
 314
 315             /* Just copy the rest of the data to the end of the old buffer. */
 316             pos = *s + bytes_handled;
 317             memcpy(pos, str, len);
 318             last_char = pos + len - 1;
 319
 320             /* We've now processed that new data - update accordingly. */
 321             bytes_handled += len;
 322         }
 323
 324         /* If we got a full line of input, stop reading */
 325         if (last_char && (*last_char == APR_ASCII_LF)) {
 326             break;
 327         }
 328     }
 329
 330     /* Now NUL-terminate the string at the end of the line;
 331      * if the last-but-one character is a CR, terminate there */
 332     if (last_char > *s && last_char[-1] == APR_ASCII_CR) {
 333         last_char--;
 334     }
 335     *last_char = '\0';
 336     bytes_handled = last_char - *s;
 337
 338     /* If we're folding, we have more work to do.
 339      *
 340      * Note that if an EOS was seen, we know we can't have another line.
 341      */
 342     if (fold && bytes_handled && !saw_eos) {
 343         for (;;) {
 344             const char *str;
 345             apr_size_t len;
 346             char c;
 347
 348             /* Clear the temp brigade for this filter read. */
 349             apr_brigade_cleanup(bb);
 350
 351             /* We only care about the first byte. */
 352             rv = ap_get_brigade(r->proto_input_filters, bb, AP_MODE_SPECULATIVE,
 353                                 APR_BLOCK_READ, 1);
 354             if (rv != APR_SUCCESS) {
 355                 return rv;
 356             }
 357
 358             if (APR_BRIGADE_EMPTY(bb)) {
 359                 break;
 360             }
 361
 362             e = APR_BRIGADE_FIRST(bb);
 363
 364             /* If we see an EOS, don't bother doing anything more. */
 365             if (APR_BUCKET_IS_EOS(e)) {
 366                 break;
 367             }
 368
 369             rv = apr_bucket_read(e, &str, &len, APR_BLOCK_READ);
 370             if (rv != APR_SUCCESS) {
 371                 apr_brigade_cleanup(bb);
 372                 return rv;
 373             }
 374
 375             /* Found one, so call ourselves again to get the next line.
 376              *
 377              * FIXME: If the folding line is completely blank, should we
 378              * stop folding?  Does that require also looking at the next
 379              * char?
 380              */
 381             /* When we call destroy, the buckets are deleted, so save that
 382              * one character we need.  This simplifies our execution paths
 383              * at the cost of one character read.
 384              */
 385             c = *str;
 386             if (c == APR_ASCII_BLANK || c == APR_ASCII_TAB) {
 387                 /* Do we have enough space? We may be full now. */
 388                 if (bytes_handled >= n) {
 389                     *read = n;
 390                     /* ensure this string is terminated */
 391                     (*s)[n-1] = '\0';
 392                     return APR_ENOSPC;
 393                 }
 394                 else {
 395                     apr_size_t next_size, next_len;
 396                     char *tmp;
 397
 398                     /* If we're doing the allocations for them, we have to
 399                      * give ourselves a NULL and copy it on return.
 400                      */
 401                     if (do_alloc) {
 402                         tmp = NULL;
 403                     } else {
 404                         /* We're null terminated. */
 405                         tmp = last_char;
 406                     }
 407
 408                     next_size = n - bytes_handled;
 409
 410                     rv = ap_rgetline_core(&tmp, next_size,
 411                                           &next_len, r, 0, bb);
 412                     if (rv != APR_SUCCESS) {
 413                         return rv;
 414                     }
 415
 416                     if (do_alloc && next_len > 0) {
 417                         char *new_buffer;
 418                         apr_size_t new_size = bytes_handled + next_len + 1;
 419
 420                         /* we need to alloc an extra byte for a null */
 421                         new_buffer = apr_palloc(r->pool, new_size);
 422
 423                         /* Copy what we already had. */
 424                         memcpy(new_buffer, *s, bytes_handled);
 425
 426                         /* copy the new line, including the trailing null */
 427                         memcpy(new_buffer + bytes_handled, tmp, next_len + 1);
 428                         *s = new_buffer;
 429                     }
 430
 431                     last_char += next_len;
 432                     bytes_handled += next_len;
 433                 }
 434             }
 435             else { /* next character is not tab or space */
 436                 break;
 437             }
 438         }
 439     }
 440     *read = bytes_handled;
 441
 442     /* PR#43039: We shouldn't accept NULL bytes within the line */
 443     if (strlen(*s) < bytes_handled) {
 444         return APR_EINVAL;
 445     }
 446
 447     return APR_SUCCESS;
 448 }
 449
 450 #if APR_CHARSET_EBCDIC
 451 AP_DECLARE(apr_status_t) ap_rgetline(char **s, apr_size_t n,
 452                                      apr_size_t *read, request_rec *r,
 453                                      int fold, apr_bucket_brigade *bb)
 454 {
 455     /* on ASCII boxes, ap_rgetline is a macro which simply invokes
 456      * ap_rgetline_core with the same parms
 457      *
 458      * on EBCDIC boxes, each complete http protocol input line needs to be
 459      * translated into the code page used by the compiler.  Since
 460      * ap_rgetline_core uses recursion, we do the translation in a wrapper
 461      * function to ensure that each input character gets translated only once.
 462      */
 463     apr_status_t rv;
 464
 465     rv = ap_rgetline_core(s, n, read, r, fold, bb);
 466     if (rv == APR_SUCCESS) {
 467         ap_xlate_proto_from_ascii(*s, *read);
 468     }
 469     return rv;
 470 }
 471 #endif
 472
 473 AP_DECLARE(int) ap_getline(char *s, int n, request_rec *r, int fold)
 474 {
 475     char *tmp_s = s;
 476     apr_status_t rv;
 477     apr_size_t len;
 478     apr_bucket_brigade *tmp_bb;
 479
 480     tmp_bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
 481     rv = ap_rgetline(&tmp_s, n, &len, r, fold, tmp_bb);
 482     apr_brigade_destroy(tmp_bb);
 483
 484     /* Map the out-of-space condition to the old API. */
 485     if (rv == APR_ENOSPC) {
 486         return n;
 487     }
 488
 489     /* Anything else is just bad. */
 490     if (rv != APR_SUCCESS) {
 491         return -1;
 492     }
 493
 494     return (int)len;
 495 }
 496
 497 /* parse_uri: break apart the uri
 498  * Side Effects:
 499  * - sets r->args to rest after '?' (or NULL if no '?')
 500  * - sets r->uri to request uri (without r->args part)
 501  * - sets r->hostname (if not set already) from request (scheme://host:port)
 502  */
 503 AP_CORE_DECLARE(void) ap_parse_uri(request_rec *r, const char *uri)
 504 {
 505     int status = HTTP_OK;
 506
 507     r->unparsed_uri = apr_pstrdup(r->pool, uri);
 508
 509     /* http://issues.apache.org/bugzilla/show_bug.cgi?id=31875
 510      * http://issues.apache.org/bugzilla/show_bug.cgi?id=28450
 511      *
 512      * This is not in fact a URI, it's a path.  That matters in the
 513      * case of a leading double-slash.  We need to resolve the issue
 514      * by normalising that out before treating it as a URI.
 515      */
 516     while ((uri[0] == '/') && (uri[1] == '/')) {
 517         ++uri ;
 518     }
 519     if (r->method_number == M_CONNECT) {
 520         status = apr_uri_parse_hostinfo(r->pool, uri, &r->parsed_uri);
 521     }
 522     else {
 523         status = apr_uri_parse(r->pool, uri, &r->parsed_uri);
 524     }
 525
 526     if (status == APR_SUCCESS) {
 527         /* if it has a scheme we may need to do absoluteURI vhost stuff */
 528         if (r->parsed_uri.scheme
 529             && !strcasecmp(r->parsed_uri.scheme, ap_http_scheme(r))) {
 530             r->hostname = r->parsed_uri.hostname;
 531         }
 532         else if (r->method_number == M_CONNECT) {
 533             r->hostname = r->parsed_uri.hostname;
 534         }
 535
 536         r->args = r->parsed_uri.query;
 537         r->uri = r->parsed_uri.path ? r->parsed_uri.path
 538                  : apr_pstrdup(r->pool, "/");
 539
 540 #if defined(OS2) || defined(WIN32)
 541         /* Handle path translations for OS/2 and plug security hole.
 542          * This will prevent "http://www.wherever.com/..\..\/" from
 543          * returning a directory for the root drive.
 544          */
 545         {
 546             char *x;
 547
 548             for (x = r->uri; (x = strchr(x, '\\')) != NULL; )
 549                 *x = '/';
 550         }
 551 #endif /* OS2 || WIN32 */
 552     }
 553     else {
 554         r->args = NULL;
 555         r->hostname = NULL;
 556         r->status = HTTP_BAD_REQUEST;             /* set error status */
 557         r->uri = apr_pstrdup(r->pool, uri);
 558     }
 559 }
 560
 561 static int read_request_line(request_rec *r, apr_bucket_brigade *bb)
 562 {
 563     const char *ll;
 564     const char *uri;
 565     const char *pro;
 566
 567     unsigned int major = 1, minor = 0;   /* Assume HTTP/1.0 if non-"HTTP" protocol */
 568     char http[5];
 569     apr_size_t len;
 570     int num_blank_lines = DEFAULT_LIMIT_BLANK_LINES;
 571     core_server_config *conf = ap_get_core_module_config(r->server->module_config);
 572     int strict = conf->http_conformance & AP_HTTP_CONFORMANCE_STRICT;
 573     int enforce_strict = !(conf->http_conformance & AP_HTTP_CONFORMANCE_LOGONLY);
 574
 575     /* Read past empty lines until we get a real request line,
 576      * a read error, the connection closes (EOF), or we timeout.
 577      *
 578      * We skip empty lines because browsers have to tack a CRLF on to the end
 579      * of POSTs to support old CERN webservers.  But note that we may not
 580      * have flushed any previous response completely to the client yet.
 581      * We delay the flush as long as possible so that we can improve
 582      * performance for clients that are pipelining requests.  If a request
 583      * is pipelined then we won't block during the (implicit) read() below.
 584      * If the requests aren't pipelined, then the client is still waiting
 585      * for the final buffer flush from us, and we will block in the implicit
 586      * read().  B_SAFEREAD ensures that the BUFF layer flushes if it will
 587      * have to block during a read.
 588      */
 589
 590     do {
 591         apr_status_t rv;
 592
 593         /* ensure ap_rgetline allocates memory each time thru the loop
 594          * if there are empty lines
 595          */
 596         r->the_request = NULL;
 597         rv = ap_rgetline(&(r->the_request), (apr_size_t)(r->server->limit_req_line + 2),
 598                          &len, r, 0, bb);
 599
 600         if (rv != APR_SUCCESS) {
 601             r->request_time = apr_time_now();
 602
 603             /* ap_rgetline returns APR_ENOSPC if it fills up the
 604              * buffer before finding the end-of-line.  This is only going to
 605              * happen if it exceeds the configured limit for a request-line.
 606              */
 607             if (APR_STATUS_IS_ENOSPC(rv)) {
 608                 r->status    = HTTP_REQUEST_URI_TOO_LARGE;
 609             }
 610             else if (APR_STATUS_IS_TIMEUP(rv)) {
 611                 r->status = HTTP_REQUEST_TIME_OUT;
 612             }
 613             else if (APR_STATUS_IS_EINVAL(rv)) {
 614                 r->status = HTTP_BAD_REQUEST;
 615             }
 616             r->proto_num = HTTP_VERSION(1,0);
 617             r->protocol  = apr_pstrdup(r->pool, "HTTP/1.0");
 618             return 0;
 619         }
 620     } while ((len <= 0) && (--num_blank_lines >= 0));
 621
 622     if (APLOGrtrace5(r)) {
 623         ap_log_rerror(APLOG_MARK, APLOG_TRACE5, 0, r,
 624                       "Request received from client: %s",
 625                       ap_escape_logitem(r->pool, r->the_request));
 626     }
 627
 628     r->request_time = apr_time_now();
 629     ll = r->the_request;
 630     r->method = ap_getword_white(r->pool, &ll);
 631
 632     uri = ap_getword_white(r->pool, &ll);
 633
 634     if (!*r->method || !*uri) {
 635         r->status    = HTTP_BAD_REQUEST;
 636         r->proto_num = HTTP_VERSION(1,0);
 637         r->protocol  = apr_pstrdup(r->pool, "HTTP/1.0");
 638         return 0;
 639     }
 640
 641     /* Provide quick information about the request method as soon as known */
 642
 643     r->method_number = ap_method_number_of(r->method);
 644     if (r->method_number == M_GET && r->method[0] == 'H') {
 645         r->header_only = 1;
 646     }
 647
 648     ap_parse_uri(r, uri);
 649     if (r->status != HTTP_OK) {
 650         return 0;
 651     }
 652
 653     if (ll[0]) {
 654         r->assbackwards = 0;
 655         pro = ll;
 656         len = strlen(ll);
 657     } else {
 658         r->assbackwards = 1;
 659         pro = "HTTP/0.9";
 660         len = 8;
 661         if (conf->http09_enable == AP_HTTP09_DISABLE) {
 662                 r->status = HTTP_VERSION_NOT_SUPPORTED;
 663                 r->protocol = apr_pstrmemdup(r->pool, pro, len);
 664                 /* If we deny 0.9, send error message with 1.x */
 665                 r->assbackwards = 0;
 666                 r->proto_num = HTTP_VERSION(0, 9);
 667                 r->connection->keepalive = AP_CONN_CLOSE;
 668                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02401)
 669                               "HTTP/0.9 denied by server configuration");
 670                 return 0;
 671         }
 672     }
 673     r->protocol = apr_pstrmemdup(r->pool, pro, len);
 674
 675     /* Avoid sscanf in the common case */
 676     if (len == 8
 677         && pro[0] == 'H' && pro[1] == 'T' && pro[2] == 'T' && pro[3] == 'P'
 678         && pro[4] == '/' && apr_isdigit(pro[5]) && pro[6] == '.'
 679         && apr_isdigit(pro[7])) {
 680         r->proto_num = HTTP_VERSION(pro[5] - '0', pro[7] - '0');
 681     }
 682     else {
 683         if (strict) {
 684             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02418)
 685                           "Invalid protocol '%s'", r->protocol);
 686             if (enforce_strict) {
 687                 r->proto_num = HTTP_VERSION(1,0);
 688                 r->protocol  = apr_pstrdup(r->pool, "HTTP/1.0");
 689                 r->connection->keepalive = AP_CONN_CLOSE;
 690                 r->status = HTTP_BAD_REQUEST;
 691                 return 0;
 692             }
 693         }
 694         if (3 == sscanf(r->protocol, "%4s/%u.%u", http, &major, &minor)
 695             && (strcasecmp("http", http) == 0)
 696             && (minor < HTTP_VERSION(1, 0)) ) { /* don't allow HTTP/0.1000 */
 697             r->proto_num = HTTP_VERSION(major, minor);
 698         }
 699         else {
 700             r->proto_num = HTTP_VERSION(1, 0);
 701         }
 702     }
 703
 704     if (strict) {
 705         int err = 0;
 706         if (ap_has_cntrl(r->the_request)) {
 707             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02420)
 708                           "Request line must not contain control characters");
 709             err = HTTP_BAD_REQUEST;
 710         }
 711         if (r->parsed_uri.fragment) {
 712             /* RFC3986 3.5: no fragment */
 713             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02421)
 714                           "URI must not contain a fragment");
 715             err = HTTP_BAD_REQUEST;
 716         }
 717         else if (r->parsed_uri.user || r->parsed_uri.password) {
 718             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02422)
 719                           "URI must not contain a username/password");
 720             err = HTTP_BAD_REQUEST;
 721         }
 722         else if (r->method_number == M_INVALID) {
 723             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02423)
 724                           "Invalid HTTP method string: %s", r->method);
 725             err = HTTP_NOT_IMPLEMENTED;
 726         }
 727         else if (r->assbackwards == 0 && r->proto_num < HTTP_VERSION(1, 0)) {
 728             ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02424)
 729                           "HTTP/0.x does not take a protocol");
 730             err = HTTP_BAD_REQUEST;
 731         }
 732
 733         if (err && enforce_strict) {
 734             r->status = err;
 735             return 0;
 736         }
 737     }
 738
 739     return 1;
 740 }
 741
 742 static int table_do_fn_check_lengths(void *r_, const char *key,
 743                                      const char *value)
 744 {
 745     request_rec *r = r_;
 746     if (value == NULL || r->server->limit_req_fieldsize >= strlen(value) )
 747         return 1;
 748
 749     r->status = HTTP_BAD_REQUEST;
 750     apr_table_setn(r->notes, "error-notes",
 751                    apr_pstrcat(r->pool, "Size of a request header field "
 752                                "after merging exceeds server limit.<br />"
 753                                "\n<pre>\n",
 754                                ap_escape_html(r->pool, key),
 755                                "</pre>\n", NULL));
 756     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00560) "Request header "
 757                   "exceeds LimitRequestFieldSize after merging: %s", key);
 758     return 0;
 759 }
 760
 761 /* get the length of the field name for logging, but no more than 80 bytes */
 762 #define LOG_NAME_MAX_LEN 80
 763 static int field_name_len(const char *field)
 764 {
 765     const char *end = ap_strchr_c(field, ':');
 766     if (end == NULL || end - field > LOG_NAME_MAX_LEN)
 767         return LOG_NAME_MAX_LEN;
 768     return end - field;
 769 }
 770
 771 AP_DECLARE(void) ap_get_mime_headers_core(request_rec *r, apr_bucket_brigade *bb)
 772 {
 773     char *last_field = NULL;
 774     apr_size_t last_len = 0;
 775     apr_size_t alloc_len = 0;
 776     char *field;
 777     char *value;
 778     apr_size_t len;
 779     int fields_read = 0;
 780     char *tmp_field;
 781     core_server_config *conf = ap_get_core_module_config(r->server->module_config);
 782
 783     /*
 784      * Read header lines until we get the empty separator line, a read error,
 785      * the connection closes (EOF), reach the server limit, or we timeout.
 786      */
 787     while(1) {
 788         apr_status_t rv;
 789         int folded = 0;
 790
 791         field = NULL;
 792         rv = ap_rgetline(&field, r->server->limit_req_fieldsize + 2,
 793                          &len, r, 0, bb);
 794
 795         if (rv != APR_SUCCESS) {
 796             if (APR_STATUS_IS_TIMEUP(rv)) {
 797                 r->status = HTTP_REQUEST_TIME_OUT;
 798             }
 799             else {
 800                 r->status = HTTP_BAD_REQUEST;
 801             }
 802
 803             /* ap_rgetline returns APR_ENOSPC if it fills up the buffer before
 804              * finding the end-of-line.  This is only going to happen if it
 805              * exceeds the configured limit for a field size.
 806              */
 807             if (rv == APR_ENOSPC) {
 808                 const char *field_escaped;
 809                 if (field && len) {
 810                     /* ensure ap_escape_html will terminate correctly */
 811                     field[len - 1] = '\0';
 812                     field_escaped = ap_escape_html(r->pool, field);
 813                 }
 814                 else {
 815                     field_escaped = field = "";
 816                 }
 817
 818                 apr_table_setn(r->notes, "error-notes",
 819                                apr_psprintf(r->pool,
 820                                            "Size of a request header field "
 821                                            "exceeds server limit.<br />\n"
 822                                            "<pre>\n%.*s\n</pre>\n",
 823                                            field_name_len(field_escaped),
 824                                            field_escaped));
 825                 ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00561)
 826                               "Request header exceeds LimitRequestFieldSize%s"
 827                               "%.*s",
 828                               *field ? ": " : "",
 829                               field_name_len(field), field);
 830             }
 831             return;
 832         }
 833
 834         if (last_field != NULL) {
 835             if ((len > 0) && ((*field == '\t') || *field == ' ')) {
 836                 /* This line is a continuation of the preceding line(s),
 837                  * so append it to the line that we've set aside.
 838                  * Note: this uses a power-of-two allocator to avoid
 839                  * doing O(n) allocs and using O(n^2) space for
 840                  * continuations that span many many lines.
 841                  */
 842                 apr_size_t fold_len = last_len + len + 1; /* trailing null */
 843
 844                 if (fold_len >= (apr_size_t)(r->server->limit_req_fieldsize)) {
 845                     const char *field_escaped;
 846
 847                     r->status = HTTP_BAD_REQUEST;
 848                     /* report what we have accumulated so far before the
 849                      * overflow (last_field) as the field with the problem
 850                      */
 851                     field_escaped = ap_escape_html(r->pool, last_field);
 852                     apr_table_setn(r->notes, "error-notes",
 853                                    apr_psprintf(r->pool,
 854                                                "Size of a request header field "
 855                                                "after folding "
 856                                                "exceeds server limit.<br />\n"
 857                                                "<pre>\n%.*s\n</pre>\n",
 858                                                field_name_len(field_escaped),
 859                                                field_escaped));
 860                     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00562)
 861                                   "Request header exceeds LimitRequestFieldSize "
 862                                   "after folding: %.*s",
 863                                   field_name_len(last_field), last_field);
 864                     return;
 865                 }
 866
 867                 if (fold_len > alloc_len) {
 868                     char *fold_buf;
 869                     alloc_len += alloc_len;
 870                     if (fold_len > alloc_len) {
 871                         alloc_len = fold_len;
 872                     }
 873                     fold_buf = (char *)apr_palloc(r->pool, alloc_len);
 874                     memcpy(fold_buf, last_field, last_len);
 875                     last_field = fold_buf;
 876                 }
 877                 memcpy(last_field + last_len, field, len +1); /* +1 for nul */
 878                 last_len += len;
 879                 folded = 1;
 880             }
 881             else /* not a continuation line */ {
 882
 883                 if (r->server->limit_req_fields
 884                     && (++fields_read > r->server->limit_req_fields)) {
 885                     r->status = HTTP_BAD_REQUEST;
 886                     apr_table_setn(r->notes, "error-notes",
 887                                    "The number of request header fields "
 888                                    "exceeds this server's limit.");
 889                     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00563)
 890                                   "Number of request headers exceeds "
 891                                   "LimitRequestFields");
 892                     return;
 893                 }
 894
 895                 if (!(value = strchr(last_field, ':'))) { /* Find ':' or    */
 896                     r->status = HTTP_BAD_REQUEST;      /* abort bad request */
 897                     apr_table_setn(r->notes, "error-notes",
 898                                    apr_psprintf(r->pool,
 899                                                "Request header field is "
 900                                                "missing ':' separator.<br />\n"
 901                                                "<pre>\n%.*s</pre>\n",
 902                                                (int)LOG_NAME_MAX_LEN,
 903                                                ap_escape_html(r->pool,
 904                                                               last_field)));
 905                     ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00564)
 906                                   "Request header field is missing ':' "
 907                                   "separator: %.*s", (int)LOG_NAME_MAX_LEN,
 908                                   last_field);
 909                     return;
 910                 }
 911
 912                 tmp_field = value - 1; /* last character of field-name */
 913
 914                 *value++ = '\0'; /* NUL-terminate at colon */
 915
 916                 while (*value == ' ' || *value == '\t') {
 917                     ++value;            /* Skip to start of value   */
 918                 }
 919
 920                 /* Strip LWS after field-name: */
 921                 while (tmp_field > last_field
 922                        && (*tmp_field == ' ' || *tmp_field == '\t')) {
 923                     *tmp_field-- = '\0';
 924                 }
 925
 926                 /* Strip LWS after field-value: */
 927                 tmp_field = last_field + last_len - 1;
 928                 while (tmp_field > value
 929                        && (*tmp_field == ' ' || *tmp_field == '\t')) {
 930                     *tmp_field-- = '\0';
 931                 }
 932
 933                 if (conf->http_conformance & AP_HTTP_CONFORMANCE_STRICT) {
 934                     int err = 0;
 935
 936                     if (*last_field == '\0') {
 937                         err = HTTP_BAD_REQUEST;
 938                         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(02425)
 939                                       "Empty request header field name not allowed");
 940                     }
 941                     else if (ap_has_cntrl(last_field)) {
 942                         err = HTTP_BAD_REQUEST;
 943                         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(02426)
 944                                       "[HTTP strict] Request header field name contains "
 945                                       "control character: %.*s",
 946                                       (int)LOG_NAME_MAX_LEN, last_field);
 947                     }
 948                     else if (ap_has_cntrl(value)) {
 949                         err = HTTP_BAD_REQUEST;
 950                         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(02427)
 951                                       "Request header field '%.*s' contains "
 952                                       "control character", (int)LOG_NAME_MAX_LEN,
 953                                       last_field);
 954                     }
 955                     if (err && !(conf->http_conformance & AP_HTTP_CONFORMANCE_LOGONLY)) {
 956                         r->status = err;
 957                         return;
 958                     }
 959                 }
 960                 apr_table_addn(r->headers_in, last_field, value);
 961
 962                 /* reset the alloc_len so that we'll allocate a new
 963                  * buffer if we have to do any more folding: we can't
 964                  * use the previous buffer because its contents are
 965                  * now part of r->headers_in
 966                  */
 967                 alloc_len = 0;
 968
 969             } /* end if current line is not a continuation starting with tab */
 970         }
 971
 972         /* Found a blank line, stop. */
 973         if (len == 0) {
 974             break;
 975         }
 976
 977         /* Keep track of this line so that we can parse it on
 978          * the next loop iteration.  (In the folded case, last_field
 979          * has been updated already.)
 980          */
 981         if (!folded) {
 982             last_field = field;
 983             last_len = len;
 984         }
 985     }
 986
 987     /* Combine multiple message-header fields with the same
 988      * field-name, following RFC 2616, 4.2.
 989      */
 990     apr_table_compress(r->headers_in, APR_OVERLAP_TABLES_MERGE);
 991
 992     /* enforce LimitRequestFieldSize for merged headers */
 993     apr_table_do(table_do_fn_check_lengths, r, r->headers_in, NULL);
 994 }
 995
 996 AP_DECLARE(void) ap_get_mime_headers(request_rec *r)
 997 {
 998     apr_bucket_brigade *tmp_bb;
 999     tmp_bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
1000     ap_get_mime_headers_core(r, tmp_bb);
1001     apr_brigade_destroy(tmp_bb);
1002 }
1003
1004 request_rec *ap_read_request(conn_rec *conn)
1005 {
1006     request_rec *r;
1007     apr_pool_t *p;
1008     const char *expect;
1009     int access_status;
1010     apr_bucket_brigade *tmp_bb;
1011     apr_socket_t *csd;
1012     apr_interval_time_t cur_timeout;
1013
1014
1015     apr_pool_create(&p, conn->pool);
1016     apr_pool_tag(p, "request");
1017     r = apr_pcalloc(p, sizeof(request_rec));
1018     AP_READ_REQUEST_ENTRY((intptr_t)r, (uintptr_t)conn);
1019     r->pool            = p;
1020     r->connection      = conn;
1021     r->server          = conn->base_server;
1022
1023     r->user            = NULL;
1024     r->ap_auth_type    = NULL;
1025
1026     r->allowed_methods = ap_make_method_list(p, 2);
1027
1028     r->headers_in      = apr_table_make(r->pool, 25);
1029     r->trailers_in     = apr_table_make(r->pool, 5);
1030     r->subprocess_env  = apr_table_make(r->pool, 25);
1031     r->headers_out     = apr_table_make(r->pool, 12);
1032     r->err_headers_out = apr_table_make(r->pool, 5);
1033     r->trailers_out    = apr_table_make(r->pool, 5);
1034     r->notes           = apr_table_make(r->pool, 5);
1035
1036     r->request_config  = ap_create_request_config(r->pool);
1037     /* Must be set before we run create request hook */
1038
1039     r->proto_output_filters = conn->output_filters;
1040     r->output_filters  = r->proto_output_filters;
1041     r->proto_input_filters = conn->input_filters;
1042     r->input_filters   = r->proto_input_filters;
1043     ap_run_create_request(r);
1044     r->per_dir_config  = r->server->lookup_defaults;
1045
1046     r->sent_bodyct     = 0;                      /* bytect isn't for body */
1047
1048     r->read_length     = 0;
1049     r->read_body       = REQUEST_NO_BODY;
1050
1051     r->status          = HTTP_OK;  /* Until further notice */
1052     r->the_request     = NULL;
1053
1054     /* Begin by presuming any module can make its own path_info assumptions,
1055      * until some module interjects and changes the value.
1056      */
1057     r->used_path_info = AP_REQ_DEFAULT_PATH_INFO;
1058
1059     r->useragent_addr = conn->client_addr;
1060     r->useragent_ip = conn->client_ip;
1061
1062     tmp_bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
1063
1064     ap_run_pre_read_request(r, conn);
1065
1066     /* Get the request... */
1067     if (!read_request_line(r, tmp_bb)) {
1068         switch (r->status) {
1069         case HTTP_REQUEST_URI_TOO_LARGE:
1070         case HTTP_BAD_REQUEST:
1071         case HTTP_VERSION_NOT_SUPPORTED:
1072         case HTTP_NOT_IMPLEMENTED:
1073             if (r->status == HTTP_REQUEST_URI_TOO_LARGE) {
1074                 ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00565)
1075                               "request failed: client's request-line exceeds LimitRequestLine (longer than %d)",
1076                               r->server->limit_req_line);
1077             }
1078             else if (r->method == NULL) {
1079                 ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00566)
1080                               "request failed: invalid characters in URI");
1081             }
1082             access_status = r->status;
1083             r->status = HTTP_OK;
1084             ap_die(access_status, r);
1085             ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1086             ap_run_log_transaction(r);
1087             r = NULL;
1088             apr_brigade_destroy(tmp_bb);
1089             goto traceout;
1090         case HTTP_REQUEST_TIME_OUT:
1091             ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1092             if (!r->connection->keepalives)
1093                 ap_run_log_transaction(r);
1094             apr_brigade_destroy(tmp_bb);
1095             goto traceout;
1096         default:
1097             apr_brigade_destroy(tmp_bb);
1098             r = NULL;
1099             goto traceout;
1100         }
1101     }
1102
1103     /* We may have been in keep_alive_timeout mode, so toggle back
1104      * to the normal timeout mode as we fetch the header lines,
1105      * as necessary.
1106      */
1107     csd = ap_get_conn_socket(conn);
1108     apr_socket_timeout_get(csd, &cur_timeout);
1109     if (cur_timeout != conn->base_server->timeout) {
1110         apr_socket_timeout_set(csd, conn->base_server->timeout);
1111         cur_timeout = conn->base_server->timeout;
1112     }
1113
1114     if (!r->assbackwards) {
1115         const char *tenc;
1116
1117         ap_get_mime_headers_core(r, tmp_bb);
1118         if (r->status != HTTP_OK) {
1119             ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00567)
1120                           "request failed: error reading the headers");
1121             ap_send_error_response(r, 0);
1122             ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1123             ap_run_log_transaction(r);
1124             apr_brigade_destroy(tmp_bb);
1125             goto traceout;
1126         }
1127
1128         tenc = apr_table_get(r->headers_in, "Transfer-Encoding");
1129         if (tenc) {
1130             /* http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-23
1131              * Section 3.3.3.3: "If a Transfer-Encoding header field is
1132              * present in a request and the chunked transfer coding is not
1133              * the final encoding ...; the server MUST respond with the 400
1134              * (Bad Request) status code and then close the connection".
1135              */
1136             if (!(strcasecmp(tenc, "chunked") == 0 /* fast path */
1137                     || ap_find_last_token(r->pool, tenc, "chunked"))) {
1138                 ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(02539)
1139                               "client sent unknown Transfer-Encoding "
1140                               "(%s): %s", tenc, r->uri);
1141                 r->status = HTTP_BAD_REQUEST;
1142                 conn->keepalive = AP_CONN_CLOSE;
1143                 ap_send_error_response(r, 0);
1144                 ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1145                 ap_run_log_transaction(r);
1146                 apr_brigade_destroy(tmp_bb);
1147                 goto traceout;
1148             }
1149
1150             /* http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-23
1151              * Section 3.3.3.3: "If a message is received with both a
1152              * Transfer-Encoding and a Content-Length header field, the
1153              * Transfer-Encoding overrides the Content-Length. ... A sender
1154              * MUST remove the received Content-Length field".
1155              */
1156             apr_table_unset(r->headers_in, "Content-Length");
1157         }
1158     }
1159     else {
1160         if (r->header_only) {
1161             /*
1162              * Client asked for headers only with HTTP/0.9, which doesn't send
1163              * headers! Have to dink things just to make sure the error message
1164              * comes through...
1165              */
1166             ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00568)
1167                           "client sent invalid HTTP/0.9 request: HEAD %s",
1168                           r->uri);
1169             r->header_only = 0;
1170             r->status = HTTP_BAD_REQUEST;
1171             ap_send_error_response(r, 0);
1172             ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1173             ap_run_log_transaction(r);
1174             apr_brigade_destroy(tmp_bb);
1175             goto traceout;
1176         }
1177     }
1178
1179     apr_brigade_destroy(tmp_bb);
1180
1181     /* update what we think the virtual host is based on the headers we've
1182      * now read. may update status.
1183      */
1184     ap_update_vhost_from_headers(r);
1185     access_status = r->status;
1186
1187     /* Toggle to the Host:-based vhost's timeout mode to fetch the
1188      * request body and send the response body, if needed.
1189      */
1190     if (cur_timeout != r->server->timeout) {
1191         apr_socket_timeout_set(csd, r->server->timeout);
1192         cur_timeout = r->server->timeout;
1193     }
1194
1195     /* we may have switched to another server */
1196     r->per_dir_config = r->server->lookup_defaults;
1197
1198     if ((!r->hostname && (r->proto_num >= HTTP_VERSION(1, 1)))
1199         || ((r->proto_num == HTTP_VERSION(1, 1))
1200             && !apr_table_get(r->headers_in, "Host"))) {
1201         /*
1202          * Client sent us an HTTP/1.1 or later request without telling us the
1203          * hostname, either with a full URL or a Host: header. We therefore
1204          * need to (as per the 1.1 spec) send an error.  As a special case,
1205          * HTTP/1.1 mentions twice (S9, S14.23) that a request MUST contain
1206          * a Host: header, and the server MUST respond with 400 if it doesn't.
1207          */
1208         access_status = HTTP_BAD_REQUEST;
1209         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00569)
1210                       "client sent HTTP/1.1 request without hostname "
1211                       "(see RFC2616 section 14.23): %s", r->uri);
1212     }
1213
1214     /*
1215      * Add the HTTP_IN filter here to ensure that ap_discard_request_body
1216      * called by ap_die and by ap_send_error_response works correctly on
1217      * status codes that do not cause the connection to be dropped and
1218      * in situations where the connection should be kept alive.
1219      */
1220
1221     ap_add_input_filter_handle(ap_http_input_filter_handle,
1222                                NULL, r, r->connection);
1223
1224     if (access_status != HTTP_OK
1225         || (access_status = ap_run_post_read_request(r))) {
1226         ap_die(access_status, r);
1227         ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1228         ap_run_log_transaction(r);
1229         r = NULL;
1230         goto traceout;
1231     }
1232
1233     if (((expect = apr_table_get(r->headers_in, "Expect")) != NULL)
1234         && (expect[0] != '\0')) {
1235         /*
1236          * The Expect header field was added to HTTP/1.1 after RFC 2068
1237          * as a means to signal when a 100 response is desired and,
1238          * unfortunately, to signal a poor man's mandatory extension that
1239          * the server must understand or return 417 Expectation Failed.
1240          */
1241         if (strcasecmp(expect, "100-continue") == 0) {
1242             r->expecting_100 = 1;
1243         }
1244         else {
1245             core_server_config *conf;
1246
1247             conf = ap_get_core_module_config(r->server->module_config);
1248             if (conf->http_expect_strict != AP_HTTP_EXPECT_STRICT_DISABLE) {
1249                 r->status = HTTP_EXPECTATION_FAILED;
1250                 ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00570)
1251                               "client sent an unrecognized expectation value "
1252                               "of Expect: %s", expect);
1253                 ap_send_error_response(r, 0);
1254                 ap_update_child_status(conn->sbh, SERVER_BUSY_LOG, r);
1255                 ap_run_log_transaction(r);
1256                 goto traceout;
1257             } else {
1258                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(02595)
1259                               "client sent an unrecognized expectation value "
1260                               "of Expect (not fatal): %s", expect);
1261             }
1262         }
1263     }
1264
1265     AP_READ_REQUEST_SUCCESS((uintptr_t)r, (char *)r->method, (char *)r->uri, (char *)r->server->defn_name, r->status);
1266     return r;
1267     traceout:
1268     AP_READ_REQUEST_FAILURE((uintptr_t)r);
1269     return r;
1270 }
1271
1272 /* if a request with a body creates a subrequest, remove original request's
1273  * input headers which pertain to the body which has already been read.
1274  * out-of-line helper function for ap_set_sub_req_protocol.
1275  */
1276
1277 static void strip_headers_request_body(request_rec *rnew)
1278 {
1279     apr_table_unset(rnew->headers_in, "Content-Encoding");
1280     apr_table_unset(rnew->headers_in, "Content-Language");
1281     apr_table_unset(rnew->headers_in, "Content-Length");
1282     apr_table_unset(rnew->headers_in, "Content-Location");
1283     apr_table_unset(rnew->headers_in, "Content-MD5");
1284     apr_table_unset(rnew->headers_in, "Content-Range");
1285     apr_table_unset(rnew->headers_in, "Content-Type");
1286     apr_table_unset(rnew->headers_in, "Expires");
1287     apr_table_unset(rnew->headers_in, "Last-Modified");
1288     apr_table_unset(rnew->headers_in, "Transfer-Encoding");
1289 }
1290
1291 /*
1292  * A couple of other functions which initialize some of the fields of
1293  * a request structure, as appropriate for adjuncts of one kind or another
1294  * to a request in progress.  Best here, rather than elsewhere, since
1295  * *someone* has to set the protocol-specific fields...
1296  */
1297
1298 AP_DECLARE(void) ap_set_sub_req_protocol(request_rec *rnew,
1299                                          const request_rec *r)
1300 {
1301     rnew->the_request     = r->the_request;  /* Keep original request-line */
1302
1303     rnew->assbackwards    = 1;   /* Don't send headers from this. */
1304     rnew->no_local_copy   = 1;   /* Don't try to send HTTP_NOT_MODIFIED for a
1305                                   * fragment. */
1306     rnew->method          = "GET";
1307     rnew->method_number   = M_GET;
1308     rnew->protocol        = "INCLUDED";
1309
1310     rnew->status          = HTTP_OK;
1311
1312     rnew->headers_in      = apr_table_copy(rnew->pool, r->headers_in);
1313     rnew->trailers_in     = apr_table_copy(rnew->pool, r->trailers_in);
1314
1315     /* did the original request have a body?  (e.g. POST w/SSI tags)
1316      * if so, make sure the subrequest doesn't inherit body headers
1317      */
1318     if (!r->kept_body && (apr_table_get(r->headers_in, "Content-Length")
1319         || apr_table_get(r->headers_in, "Transfer-Encoding"))) {
1320         strip_headers_request_body(rnew);
1321     }
1322     rnew->subprocess_env  = apr_table_copy(rnew->pool, r->subprocess_env);
1323     rnew->headers_out     = apr_table_make(rnew->pool, 5);
1324     rnew->err_headers_out = apr_table_make(rnew->pool, 5);
1325     rnew->trailers_out    = apr_table_make(rnew->pool, 5);
1326     rnew->notes           = apr_table_make(rnew->pool, 5);
1327
1328     rnew->expecting_100   = r->expecting_100;
1329     rnew->read_length     = r->read_length;
1330     rnew->read_body       = REQUEST_NO_BODY;
1331
1332     rnew->main = (request_rec *) r;
1333 }
1334
1335 static void error_output_stream(request_rec *r, int status)
1336 {
1337     conn_rec *c = r->connection;
1338     apr_bucket_brigade *bb;
1339     apr_bucket *b;
1340
1341     bb = apr_brigade_create(r->pool, c->bucket_alloc);
1342     b = ap_bucket_error_create(status, NULL, r->pool,
1343             r->connection->bucket_alloc);
1344     APR_BRIGADE_INSERT_TAIL(bb, b);
1345     b = apr_bucket_eos_create(c->bucket_alloc);
1346     APR_BRIGADE_INSERT_TAIL(bb, b);
1347     ap_pass_brigade(r->output_filters, bb);
1348 }
1349
1350 static void end_output_stream(request_rec *r)
1351 {
1352     conn_rec *c = r->connection;
1353     apr_bucket_brigade *bb;
1354     apr_bucket *b;
1355
1356     bb = apr_brigade_create(r->pool, c->bucket_alloc);
1357     b = apr_bucket_eos_create(c->bucket_alloc);
1358     APR_BRIGADE_INSERT_TAIL(bb, b);
1359     ap_pass_brigade(r->output_filters, bb);
1360 }
1361
1362 AP_DECLARE(void) ap_finalize_sub_req_protocol(request_rec *sub)
1363 {
1364     /* tell the filter chain there is no more content coming */
1365     if (!sub->eos_sent) {
1366         end_output_stream(sub);
1367     }
1368 }
1369
1370 /* finalize_request_protocol is called at completion of sending the
1371  * response.  Its sole purpose is to send the terminating protocol
1372  * information for any wrappers around the response message body
1373  * (i.e., transfer encodings).  It should have been named finalize_response.
1374  */
1375 AP_DECLARE(void) ap_finalize_request_protocol(request_rec *r)
1376 {
1377     int status = ap_discard_request_body(r);
1378
1379     /* tell the filter chain there is no more content coming */
1380     if (status) {
1381         error_output_stream(r, status);
1382     }
1383     if (!r->eos_sent) {
1384         end_output_stream(r);
1385     }
1386 }
1387
1388 /*
1389  * Support for the Basic authentication protocol, and a bit for Digest.
1390  */
1391 AP_DECLARE(void) ap_note_auth_failure(request_rec *r)
1392 {
1393     const char *type = ap_auth_type(r);
1394     if (type) {
1395         ap_run_note_auth_failure(r, type);
1396     }
1397     else {
1398         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00571)
1399                       "need AuthType to note auth failure: %s", r->uri);
1400     }
1401 }
1402
1403 AP_DECLARE(void) ap_note_basic_auth_failure(request_rec *r)
1404 {
1405     ap_note_auth_failure(r);
1406 }
1407
1408 AP_DECLARE(void) ap_note_digest_auth_failure(request_rec *r)
1409 {
1410     ap_note_auth_failure(r);
1411 }
1412
1413 AP_DECLARE(int) ap_get_basic_auth_pw(request_rec *r, const char **pw)
1414 {
1415     const char *auth_line = apr_table_get(r->headers_in,
1416                                           (PROXYREQ_PROXY == r->proxyreq)
1417                                               ? "Proxy-Authorization"
1418                                               : "Authorization");
1419     const char *t;
1420
1421     if (!(t = ap_auth_type(r)) || strcasecmp(t, "Basic"))
1422         return DECLINED;
1423
1424     if (!ap_auth_name(r)) {
1425         ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00572)
1426                       "need AuthName: %s", r->uri);
1427         return HTTP_INTERNAL_SERVER_ERROR;
1428     }
1429
1430     if (!auth_line) {
1431         ap_note_auth_failure(r);
1432         return HTTP_UNAUTHORIZED;
1433     }
1434
1435     if (strcasecmp(ap_getword(r->pool, &auth_line, ' '), "Basic")) {
1436         /* Client tried to authenticate using wrong auth scheme */
1437         ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(00573)
1438                       "client used wrong authentication scheme: %s", r->uri);
1439         ap_note_auth_failure(r);
1440         return HTTP_UNAUTHORIZED;
1441     }
1442
1443     while (*auth_line == ' ' || *auth_line == '\t') {
1444         auth_line++;
1445     }
1446
1447     t = ap_pbase64decode(r->pool, auth_line);
1448     r->user = ap_getword_nulls (r->pool, &t, ':');
1449     r->ap_auth_type = "Basic";
1450
1451     *pw = t;
1452
1453     return OK;
1454 }
1455
1456 struct content_length_ctx {
1457     int data_sent;  /* true if the C-L filter has already sent at
1458                      * least one bucket on to the next output filter
1459                      * for this request
1460                      */
1461     apr_bucket_brigade *tmpbb;
1462 };
1463
1464 /* This filter computes the content length, but it also computes the number
1465  * of bytes sent to the client.  This means that this filter will always run
1466  * through all of the buckets in all brigades
1467  */
1468 AP_CORE_DECLARE_NONSTD(apr_status_t) ap_content_length_filter(
1469     ap_filter_t *f,
1470     apr_bucket_brigade *b)
1471 {
1472     request_rec *r = f->r;
1473     struct content_length_ctx *ctx;
1474     apr_bucket *e;
1475     int eos = 0;
1476     apr_read_type_e eblock = APR_NONBLOCK_READ;
1477
1478     ctx = f->ctx;
1479     if (!ctx) {
1480         f->ctx = ctx = apr_palloc(r->pool, sizeof(*ctx));
1481         ctx->data_sent = 0;
1482         ctx->tmpbb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
1483     }
1484
1485     /* Loop through this set of buckets to compute their length
1486      */
1487     e = APR_BRIGADE_FIRST(b);
1488     while (e != APR_BRIGADE_SENTINEL(b)) {
1489         if (APR_BUCKET_IS_EOS(e)) {
1490             eos = 1;
1491             break;
1492         }
1493         if (e->length == (apr_size_t)-1) {
1494             apr_size_t len;
1495             const char *ignored;
1496             apr_status_t rv;
1497
1498             /* This is probably a pipe bucket.  Send everything
1499              * prior to this, and then read the data for this bucket.
1500              */
1501             rv = apr_bucket_read(e, &ignored, &len, eblock);
1502             if (rv == APR_SUCCESS) {
1503                 /* Attempt a nonblocking read next time through */
1504                 eblock = APR_NONBLOCK_READ;
1505                 r->bytes_sent += len;
1506             }
1507             else if (APR_STATUS_IS_EAGAIN(rv)) {
1508                 /* Output everything prior to this bucket, and then
1509                  * do a blocking read on the next batch.
1510                  */
1511                 if (e != APR_BRIGADE_FIRST(b)) {
1512                     apr_bucket *flush;
1513                     apr_brigade_split_ex(b, e, ctx->tmpbb);
1514                     flush = apr_bucket_flush_create(r->connection->bucket_alloc);
1515
1516                     APR_BRIGADE_INSERT_TAIL(b, flush);
1517                     rv = ap_pass_brigade(f->next, b);
1518                     if (rv != APR_SUCCESS || f->c->aborted) {
1519                         return rv;
1520                     }
1521                     apr_brigade_cleanup(b);
1522                     APR_BRIGADE_CONCAT(b, ctx->tmpbb);
1523                     e = APR_BRIGADE_FIRST(b);
1524
1525                     ctx->data_sent = 1;
1526                 }
1527                 eblock = APR_BLOCK_READ;
1528                 continue;
1529             }
1530             else {
1531                 ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(00574)
1532                               "ap_content_length_filter: "
1533                               "apr_bucket_read() failed");
1534                 return rv;
1535             }
1536         }
1537         else {
1538             r->bytes_sent += e->length;
1539         }
1540         e = APR_BUCKET_NEXT(e);
1541     }
1542
1543     /* If we've now seen the entire response and it's otherwise
1544      * okay to set the C-L in the response header, then do so now.
1545      *
1546      * We can only set a C-L in the response header if we haven't already
1547      * sent any buckets on to the next output filter for this request.
1548      */
1549     if (ctx->data_sent == 0 && eos) {
1550         core_server_config *conf =
1551             ap_get_core_module_config(r->server->module_config);
1552
1553         /* This is a hack, but I can't find anyway around it.  The idea is that
1554          * we don't want to send out 0 Content-Lengths if it is a HEAD request.
1555          * [Unless the corresponding body (for a GET) would really be empty!]
1556          * This happens when modules try to outsmart the server, and return
1557          * if they see a HEAD request.  Apache 1.3 handlers were supposed to
1558          * just return in that situation, and the core handled the HEAD.  From
1559          * 2.0, if a handler returns, then the core sends an EOS bucket down
1560          * the filter stack, and this content-length filter computes a length
1561          * of zero and we would end up sending a zero C-L to the client.
1562          * We can't just remove the this C-L filter, because well behaved 2.0+
1563          * handlers will send their data down the stack, and we will compute
1564          * a real C-L for the head request. RBB
1565          *
1566          * Allow modification of this behavior through the
1567          * HttpContentLengthHeadZero directive.
1568          *
1569          * The default (unset) behavior is to squelch the C-L in this case.
1570          */
1571
1572         /* don't whack the C-L if it has already been set for a HEAD
1573          * by something like proxy.  the brigade only has an EOS bucket
1574          * in this case, making r->bytes_sent zero, and either there is
1575          * an existing C-L we want to preserve, or r->sent_bodyct is not
1576          * zero (the empty body is being sent) thus we don't want to add
1577          * a C-L of zero (the backend did not provide it, neither do we).
1578          *
1579          * if r->bytes_sent > 0 we have a (temporary) body whose length may
1580          * have been changed by a filter.  the C-L header might not have been
1581          * updated so we do it here.  long term it would be cleaner to have
1582          * such filters update or remove the C-L header, and just use it
1583          * if present.
1584          */
1585         if (!(r->header_only
1586               && !r->bytes_sent
1587               && (r->sent_bodyct
1588                   || conf->http_cl_head_zero != AP_HTTP_CL_HEAD_ZERO_ENABLE
1589                   || apr_table_get(r->headers_out, "Content-Length")))) {
1590             ap_set_content_length(r, r->bytes_sent);
1591         }
1592     }
1593
1594     ctx->data_sent = 1;
1595     return ap_pass_brigade(f->next, b);
1596 }
1597
1598 /*
1599  * Send the body of a response to the client.
1600  */
1601 AP_DECLARE(apr_status_t) ap_send_fd(apr_file_t *fd, request_rec *r,
1602                                     apr_off_t offset, apr_size_t len,
1603                                     apr_size_t *nbytes)
1604 {
1605     conn_rec *c = r->connection;
1606     apr_bucket_brigade *bb = NULL;
1607     apr_status_t rv;
1608
1609     bb = apr_brigade_create(r->pool, c->bucket_alloc);
1610
1611     apr_brigade_insert_file(bb, fd, offset, len, r->pool);
1612
1613     rv = ap_pass_brigade(r->output_filters, bb);
1614     if (rv != APR_SUCCESS) {
1615         *nbytes = 0; /* no way to tell how many were actually sent */
1616     }
1617     else {
1618         *nbytes = len;
1619     }
1620
1621     return rv;
1622 }
1623
1624 #if APR_HAS_MMAP
1625 /* send data from an in-memory buffer */
1626 AP_DECLARE(apr_size_t) ap_send_mmap(apr_mmap_t *mm,
1627                                     request_rec *r,
1628                                     apr_size_t offset,
1629                                     apr_size_t length)
1630 {
1631     conn_rec *c = r->connection;
1632     apr_bucket_brigade *bb = NULL;
1633     apr_bucket *b;
1634
1635     bb = apr_brigade_create(r->pool, c->bucket_alloc);
1636     b = apr_bucket_mmap_create(mm, offset, length, c->bucket_alloc);
1637     APR_BRIGADE_INSERT_TAIL(bb, b);
1638     ap_pass_brigade(r->output_filters, bb);
1639
1640     return mm->size; /* XXX - change API to report apr_status_t? */
1641 }
1642 #endif /* APR_HAS_MMAP */
1643
1644 typedef struct {
1645     apr_bucket_brigade *bb;
1646     apr_bucket_brigade *tmpbb;
1647 } old_write_filter_ctx;
1648
1649 AP_CORE_DECLARE_NONSTD(apr_status_t) ap_old_write_filter(
1650     ap_filter_t *f, apr_bucket_brigade *bb)
1651 {
1652     old_write_filter_ctx *ctx = f->ctx;
1653
1654     AP_DEBUG_ASSERT(ctx);
1655
1656     if (ctx->bb != NULL) {
1657         /* whatever is coming down the pipe (we don't care), we
1658          * can simply insert our buffered data at the front and
1659          * pass the whole bundle down the chain.
1660          */
1661         APR_BRIGADE_PREPEND(bb, ctx->bb);
1662     }
1663
1664     return ap_pass_brigade(f->next, bb);
1665 }
1666
1667 static ap_filter_t *insert_old_write_filter(request_rec *r)
1668 {
1669     ap_filter_t *f;
1670     old_write_filter_ctx *ctx;
1671
1672     /* future optimization: record some flags in the request_rec to
1673      * say whether we've added our filter, and whether it is first.
1674      */
1675
1676     /* this will typically exit on the first test */
1677     for (f = r->output_filters; f != NULL; f = f->next) {
1678         if (ap_old_write_func == f->frec)
1679             break;
1680     }
1681
1682     if (f == NULL) {
1683         /* our filter hasn't been added yet */
1684         ctx = apr_pcalloc(r->pool, sizeof(*ctx));
1685         ctx->tmpbb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
1686
1687         ap_add_output_filter("OLD_WRITE", ctx, r, r->connection);
1688         f = r->output_filters;
1689     }
1690
1691     return f;
1692 }
1693
1694 static apr_status_t buffer_output(request_rec *r,
1695                                   const char *str, apr_size_t len)
1696 {
1697     conn_rec *c = r->connection;
1698     ap_filter_t *f;
1699     old_write_filter_ctx *ctx;
1700
1701     if (len == 0)
1702         return APR_SUCCESS;
1703
1704     f = insert_old_write_filter(r);
1705     ctx = f->ctx;
1706
1707     /* if the first filter is not our buffering filter, then we have to
1708      * deliver the content through the normal filter chain
1709      */
1710     if (f != r->output_filters) {
1711         apr_status_t rv;
1712         apr_bucket *b = apr_bucket_transient_create(str, len, c->bucket_alloc);
1713         APR_BRIGADE_INSERT_TAIL(ctx->tmpbb, b);
1714
1715         rv = ap_pass_brigade(r->output_filters, ctx->tmpbb);
1716         apr_brigade_cleanup(ctx->tmpbb);
1717         return rv;
1718     }
1719
1720     if (ctx->bb == NULL) {
1721         ctx->bb = apr_brigade_create(r->pool, c->bucket_alloc);
1722     }
1723
1724     return ap_fwrite(f->next, ctx->bb, str, len);
1725 }
1726
1727 AP_DECLARE(int) ap_rputc(int c, request_rec *r)
1728 {
1729     char c2 = (char)c;
1730
1731     if (r->connection->aborted) {
1732         return -1;
1733     }
1734
1735     if (buffer_output(r, &c2, 1) != APR_SUCCESS)
1736         return -1;
1737
1738     return c;
1739 }
1740
1741 AP_DECLARE(int) ap_rwrite(const void *buf, int nbyte, request_rec *r)
1742 {
1743     if (r->connection->aborted)
1744         return -1;
1745
1746     if (buffer_output(r, buf, nbyte) != APR_SUCCESS)
1747         return -1;
1748
1749     return nbyte;
1750 }
1751
1752 struct ap_vrprintf_data {
1753     apr_vformatter_buff_t vbuff;
1754     request_rec *r;
1755     char *buff;
1756 };
1757
1758 /* Flush callback for apr_vformatter; returns -1 on error. */
1759 static int r_flush(apr_vformatter_buff_t *buff)
1760 {
1761     /* callback function passed to ap_vformatter to be called when
1762      * vformatter needs to write into buff and buff.curpos > buff.endpos */
1763
1764     /* ap_vrprintf_data passed as a apr_vformatter_buff_t, which is then
1765      * "downcast" to an ap_vrprintf_data */
1766     struct ap_vrprintf_data *vd = (struct ap_vrprintf_data*)buff;
1767
1768     if (vd->r->connection->aborted)
1769         return -1;
1770
1771     /* r_flush is called when vbuff is completely full */
1772     if (buffer_output(vd->r, vd->buff, AP_IOBUFSIZE)) {
1773         return -1;
1774     }
1775
1776     /* reset the buffer position */
1777     vd->vbuff.curpos = vd->buff;
1778     vd->vbuff.endpos = vd->buff + AP_IOBUFSIZE;
1779
1780     return 0;
1781 }
1782
1783 AP_DECLARE(int) ap_vrprintf(request_rec *r, const char *fmt, va_list va)
1784 {
1785     apr_size_t written;
1786     struct ap_vrprintf_data vd;
1787     char vrprintf_buf[AP_IOBUFSIZE];
1788
1789     vd.vbuff.curpos = vrprintf_buf;
1790     vd.vbuff.endpos = vrprintf_buf + AP_IOBUFSIZE;
1791     vd.r = r;
1792     vd.buff = vrprintf_buf;
1793
1794     if (r->connection->aborted)
1795         return -1;
1796
1797     written = apr_vformatter(r_flush, &vd.vbuff, fmt, va);
1798
1799     if (written != -1) {
1800         int n = vd.vbuff.curpos - vrprintf_buf;
1801
1802         /* last call to buffer_output, to finish clearing the buffer */
1803         if (buffer_output(r, vrprintf_buf,n) != APR_SUCCESS)
1804             return -1;
1805
1806         written += n;
1807     }
1808
1809     return written;
1810 }
1811
1812 AP_DECLARE_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt, ...)
1813 {
1814     va_list va;
1815     int n;
1816
1817     if (r->connection->aborted)
1818         return -1;
1819
1820     va_start(va, fmt);
1821     n = ap_vrprintf(r, fmt, va);
1822     va_end(va);
1823
1824     return n;
1825 }
1826
1827 AP_DECLARE_NONSTD(int) ap_rvputs(request_rec *r, ...)
1828 {
1829     va_list va;
1830     const char *s;
1831     apr_size_t len;
1832     apr_size_t written = 0;
1833
1834     if (r->connection->aborted)
1835         return -1;
1836
1837     /* ### TODO: if the total output is large, put all the strings
1838      * ### into a single brigade, rather than flushing each time we
1839      * ### fill the buffer
1840      */
1841     va_start(va, r);
1842     while (1) {
1843         s = va_arg(va, const char *);
1844         if (s == NULL)
1845             break;
1846
1847         len = strlen(s);
1848         if (buffer_output(r, s, len) != APR_SUCCESS) {
1849             return -1;
1850         }
1851
1852         written += len;
1853     }
1854     va_end(va);
1855
1856     return written;
1857 }
1858
1859 AP_DECLARE(int) ap_rflush(request_rec *r)
1860 {
1861     conn_rec *c = r->connection;
1862     apr_bucket *b;
1863     ap_filter_t *f;
1864     old_write_filter_ctx *ctx;
1865     apr_status_t rv;
1866
1867     f = insert_old_write_filter(r);
1868     ctx = f->ctx;
1869
1870     b = apr_bucket_flush_create(c->bucket_alloc);
1871     APR_BRIGADE_INSERT_TAIL(ctx->tmpbb, b);
1872
1873     rv = ap_pass_brigade(r->output_filters, ctx->tmpbb);
1874     apr_brigade_cleanup(ctx->tmpbb);
1875     if (rv != APR_SUCCESS)
1876         return -1;
1877
1878     return 0;
1879 }
1880
1881 /*
1882  * This function sets the Last-Modified output header field to the value
1883  * of the mtime field in the request structure - rationalized to keep it from
1884  * being in the future.
1885  */
1886 AP_DECLARE(void) ap_set_last_modified(request_rec *r)
1887 {
1888     if (!r->assbackwards) {
1889         apr_time_t mod_time = ap_rationalize_mtime(r, r->mtime);
1890         char *datestr = apr_palloc(r->pool, APR_RFC822_DATE_LEN);
1891
1892         apr_rfc822_date(datestr, mod_time);
1893         apr_table_setn(r->headers_out, "Last-Modified", datestr);
1894     }
1895 }
1896
1897 typedef struct hdr_ptr {
1898     ap_filter_t *f;
1899     apr_bucket_brigade *bb;
1900 } hdr_ptr;
1901 static int send_header(void *data, const char *key, const char *val)
1902 {
1903     ap_fputstrs(((hdr_ptr*)data)->f, ((hdr_ptr*)data)->bb,
1904                 key, ": ", val, CRLF, NULL);
1905     return 1;
1906 }
1907 AP_DECLARE(void) ap_send_interim_response(request_rec *r, int send_headers)
1908 {
1909     hdr_ptr x;
1910     char *status_line = NULL;
1911     request_rec *rr;
1912
1913     if (r->proto_num < HTTP_VERSION(1,1)) {
1914         /* don't send interim response to HTTP/1.0 Client */
1915         return;
1916     }
1917     if (!ap_is_HTTP_INFO(r->status)) {
1918         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(00575)
1919                       "Status is %d - not sending interim response", r->status);
1920         return;
1921     }
1922     if ((r->status == HTTP_CONTINUE) && !r->expecting_100) {
1923         /*
1924          * Don't send 100-Continue when there was no Expect: 100-continue
1925          * in the request headers. For origin servers this is a SHOULD NOT
1926          * for proxies it is a MUST NOT according to RFC 2616 8.2.3
1927          */
1928         return;
1929     }
1930
1931     /* if we send an interim response, we're no longer in a state of
1932      * expecting one.  Also, this could feasibly be in a subrequest,
1933      * so we need to propagate the fact that we responded.
1934      */
1935     for (rr = r; rr != NULL; rr = rr->main) {
1936         rr->expecting_100 = 0;
1937     }
1938
1939     status_line = apr_pstrcat(r->pool, AP_SERVER_PROTOCOL, " ", r->status_line, CRLF, NULL);
1940     ap_xlate_proto_to_ascii(status_line, strlen(status_line));
1941
1942     x.f = r->connection->output_filters;
1943     x.bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
1944
1945     ap_fputs(x.f, x.bb, status_line);
1946     if (send_headers) {
1947         apr_table_do(send_header, &x, r->headers_out, NULL);
1948         apr_table_clear(r->headers_out);
1949     }
1950     ap_fputs(x.f, x.bb, CRLF_ASCII);
1951     ap_fflush(x.f, x.bb);
1952     apr_brigade_destroy(x.bb);
1953 }
1954
1955 /*
1956  * Compare two protocol identifier. Result is similar to strcmp():
1957  * 0 gives same precedence, >0 means proto1 is preferred.
1958  */
1959 static int protocol_cmp(const apr_array_header_t *preferences,
1960                         const char *proto1,
1961                         const char *proto2)
1962 {
1963     if (preferences && preferences->nelts > 0) {
1964         int index1 = ap_array_str_index(preferences, proto1, 0);
1965         int index2 = ap_array_str_index(preferences, proto2, 0);
1966         if (index2 > index1) {
1967             return (index1 >= 0) ? 1 : -1;
1968         }
1969         else if (index1 > index2) {
1970             return (index2 >= 0) ? -1 : 1;
1971         }
1972     }
1973     /* both have the same index (mabye -1 or no pref configured) and we compare
1974      * the names so that spdy3 gets precedence over spdy2. That makes
1975      * the outcome at least deterministic. */
1976     return strcmp(proto1, proto2);
1977 }
1978
1979 AP_DECLARE(const char *) ap_get_protocol(conn_rec *c)
1980 {
1981     const char *protocol = ap_run_protocol_get(c);
1982     return protocol? protocol : AP_PROTOCOL_HTTP1;
1983 }
1984
1985 AP_DECLARE(apr_status_t) ap_get_protocol_upgrades(conn_rec *c, request_rec *r,
1986                                                   server_rec *s,
1987                                                   const apr_array_header_t **pupgrades)
1988 {
1989     apr_pool_t *pool = r? r->pool : c->pool;
1990     core_server_config *conf;
1991     const char *existing;
1992     apr_array_header_t *upgrades = NULL;
1993
1994     if (!s) {
1995         s = (r? r->server : c->base_server);
1996     }
1997     conf = ap_get_core_module_config(s->module_config);
1998
1999     if (conf->protocols->nelts > 0) {
2000         existing = ap_get_protocol(c);
2001         if (conf->protocols->nelts > 1
2002             || !ap_array_str_contains(conf->protocols, existing)) {
2003             int i;
2004
2005             /* possibly more than one choice or one, but not the
2006              * existing. (TODO: maybe 426 and Upgrade then?) */
2007             upgrades = apr_array_make(pool, conf->protocols->nelts + 1,
2008                                       sizeof(char *));
2009             for (i = 0; i < conf->protocols->nelts; i++) {
2010                 const char *p = APR_ARRAY_IDX(conf->protocols, i, char *);
2011                 if (strcmp(existing, p)) {
2012                     /* not the one we have and possible, add in this order */
2013                     APR_ARRAY_PUSH(upgrades, const char*) = p;
2014                 }
2015             }
2016         }
2017     }
2018
2019     *pupgrades = upgrades;
2020     return APR_SUCCESS;
2021 }
2022
2023 AP_DECLARE(const char *) ap_select_protocol(conn_rec *c, request_rec *r,
2024                                             server_rec *s,
2025                                             const apr_array_header_t *choices)
2026 {
2027     apr_pool_t *pool = r? r->pool : c->pool;
2028     core_server_config *conf;
2029     const char *protocol = NULL, *existing;
2030     apr_array_header_t *proposals;
2031
2032     if (!s) {
2033         s = (r? r->server : c->base_server);
2034     }
2035     conf = ap_get_core_module_config(s->module_config);
2036
2037     if (APLOGcdebug(c)) {
2038         const char *p = apr_array_pstrcat(pool, conf->protocols, ',');
2039         ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c,
2040                       "select protocol from %s, choices=%s for server %s",
2041                       p, apr_array_pstrcat(pool, choices, ','),
2042                       s->server_hostname);
2043     }
2044
2045     if (conf->protocols->nelts <= 0) {
2046         /* nothing configured, by default, we only allow http/1.1 here.
2047          * For now...
2048          */
2049         if (ap_array_str_contains(choices, AP_PROTOCOL_HTTP1)) {
2050             return AP_PROTOCOL_HTTP1;
2051         }
2052         else {
2053             return NULL;
2054         }
2055     }
2056
2057     proposals = apr_array_make(pool, choices->nelts + 1, sizeof(char *));
2058     ap_run_protocol_propose(c, r, s, choices, proposals);
2059
2060     /* If the existing protocol has not been proposed, but is a choice,
2061      * add it to the proposals implicitly.
2062      */
2063     existing = ap_get_protocol(c);
2064     if (!ap_array_str_contains(proposals, existing)
2065         && ap_array_str_contains(choices, existing)) {
2066         APR_ARRAY_PUSH(proposals, const char*) = existing;
2067     }
2068
2069     if (proposals->nelts > 0) {
2070         int i;
2071         const apr_array_header_t *prefs = NULL;
2072
2073         /* Default for protocols_honor_order is 'on' or != 0 */
2074         if (conf->protocols_honor_order == 0 && choices->nelts > 0) {
2075             prefs = choices;
2076         }
2077         else {
2078             prefs = conf->protocols;
2079         }
2080
2081         /* Select the most preferred protocol */
2082         if (APLOGcdebug(c)) {
2083             ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c,
2084                           "select protocol, proposals=%s preferences=%s configured=%s",
2085                           apr_array_pstrcat(pool, proposals, ','),
2086                           apr_array_pstrcat(pool, prefs, ','),
2087                           apr_array_pstrcat(pool, conf->protocols, ','));
2088         }
2089         for (i = 0; i < proposals->nelts; ++i) {
2090             const char *p = APR_ARRAY_IDX(proposals, i, const char *);
2091             if (!ap_array_str_contains(conf->protocols, p)) {
2092                 /* not a configured protocol here */
2093                 continue;
2094             }
2095             else if (!protocol
2096                      || (protocol_cmp(prefs, protocol, p) < 0)) {
2097                 /* none selected yet or this one has preference */
2098                 protocol = p;
2099             }
2100         }
2101     }
2102     if (APLOGcdebug(c)) {
2103         ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, "selected protocol=%s",
2104                       protocol? protocol : "(none)");
2105     }
2106
2107     return protocol;
2108 }
2109
2110 AP_DECLARE(apr_status_t) ap_switch_protocol(conn_rec *c, request_rec *r,
2111                                             server_rec *s,
2112                                             const char *protocol)
2113 {
2114     const char *current = ap_get_protocol(c);
2115     int rc;
2116
2117     if (!strcmp(current, protocol)) {
2118         ap_log_cerror(APLOG_MARK, APLOG_WARNING, 0, c, APLOGNO(02906)
2119                       "already at it, protocol_switch to %s",
2120                       protocol);
2121         return APR_SUCCESS;
2122     }
2123
2124     rc = ap_run_protocol_switch(c, r, s, protocol);
2125     switch (rc) {
2126         case DECLINED:
2127             ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02907)
2128                           "no implementation for protocol_switch to %s",
2129                           protocol);
2130             return APR_ENOTIMPL;
2131         case OK:
2132         case DONE:
2133             return APR_SUCCESS;
2134         default:
2135             ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02905)
2136                           "unexpected return code %d from protocol_switch to %s"
2137                           , rc, protocol);
2138             return APR_EOF;
2139     }
2140 }
2141
2142 AP_DECLARE(int) ap_is_allowed_protocol(conn_rec *c, request_rec *r,
2143                                        server_rec *s, const char *protocol)
2144 {
2145     core_server_config *conf;
2146
2147     if (!s) {
2148         s = (r? r->server : c->base_server);
2149     }
2150     conf = ap_get_core_module_config(s->module_config);
2151
2152     if (conf->protocols->nelts > 0) {
2153         return ap_array_str_contains(conf->protocols, protocol);
2154     }
2155     return !strcmp(AP_PROTOCOL_HTTP1, protocol);
2156 }
2157
2158
2159 AP_IMPLEMENT_HOOK_VOID(pre_read_request,
2160                        (request_rec *r, conn_rec *c),
2161                        (r, c))
2162 AP_IMPLEMENT_HOOK_RUN_ALL(int,post_read_request,
2163                           (request_rec *r), (r), OK, DECLINED)
2164 AP_IMPLEMENT_HOOK_RUN_ALL(int,log_transaction,
2165                           (request_rec *r), (r), OK, DECLINED)
2166 AP_IMPLEMENT_HOOK_RUN_FIRST(const char *,http_scheme,
2167                             (const request_rec *r), (r), NULL)
2168 AP_IMPLEMENT_HOOK_RUN_FIRST(unsigned short,default_port,
2169                             (const request_rec *r), (r), 0)
2170 AP_IMPLEMENT_HOOK_RUN_FIRST(int, note_auth_failure,
2171                             (request_rec *r, const char *auth_type),
2172                             (r, auth_type), DECLINED)
2173 AP_IMPLEMENT_HOOK_RUN_ALL(int,protocol_propose,
2174                           (conn_rec *c, request_rec *r, server_rec *s,
2175                            const apr_array_header_t *offers,
2176                            apr_array_header_t *proposals),
2177                           (c, r, s, offers, proposals), OK, DECLINED)
2178 AP_IMPLEMENT_HOOK_RUN_FIRST(int,protocol_switch,
2179                             (conn_rec *c, request_rec *r, server_rec *s,
2180                              const char *protocol),
2181                             (c, r, s, protocol), DECLINED)
2182 AP_IMPLEMENT_HOOK_RUN_FIRST(const char *,protocol_get,
2183                             (const conn_rec *c), (c), NULL)