mirror of
https://github.com/apache/httpd.git
synced 2025-09-01 02:02:06 +03:00
e3e87d34a0
Obtained from: Apache 1.3.9 (minus unused files), tag APACHE_1_3_9 Submitted by: Apache Group git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@83751 13f79535-47bb-0310-9956-ffa450edef68
544 lines
17 KiB
C
544 lines
17 KiB
C
/* ====================================================================
|
|
* Copyright (c) 1996-1999 The Apache Group. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* 3. All advertising materials mentioning features or use of this
|
|
* software must display the following acknowledgment:
|
|
* "This product includes software developed by the Apache Group
|
|
* for use in the Apache HTTP server project (http://www.apache.org/)."
|
|
*
|
|
* 4. The names "Apache Server" and "Apache Group" must not be used to
|
|
* endorse or promote products derived from this software without
|
|
* prior written permission. For written permission, please contact
|
|
* apache@apache.org.
|
|
*
|
|
* 5. Products derived from this software may not be called "Apache"
|
|
* nor may "Apache" appear in their names without prior written
|
|
* permission of the Apache Group.
|
|
*
|
|
* 6. Redistributions of any form whatsoever must retain the following
|
|
* acknowledgment:
|
|
* "This product includes software developed by the Apache Group
|
|
* for use in the Apache HTTP server project (http://www.apache.org/)."
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
|
|
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE GROUP OR
|
|
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
* ====================================================================
|
|
*
|
|
* This software consists of voluntary contributions made by many
|
|
* individuals on behalf of the Apache Group and was originally based
|
|
* on public domain software written at the National Center for
|
|
* Supercomputing Applications, University of Illinois, Urbana-Champaign.
|
|
* For more information on the Apache Group and the Apache HTTP server
|
|
* project, please see <http://www.apache.org/>.
|
|
*
|
|
*/
|
|
|
|
/* HTTP routines for Apache proxy */
|
|
|
|
#include "mod_proxy.h"
|
|
#include "http_log.h"
|
|
#include "http_main.h"
|
|
#include "http_core.h"
|
|
#include "util_date.h"
|
|
|
|
/*
|
|
* Canonicalise http-like URLs.
|
|
* scheme is the scheme for the URL
|
|
* url is the URL starting with the first '/'
|
|
* def_port is the default port for this scheme.
|
|
*/
|
|
int ap_proxy_http_canon(request_rec *r, char *url, const char *scheme, int def_port)
|
|
{
|
|
char *host, *path, *search, sport[7];
|
|
const char *err;
|
|
int port;
|
|
|
|
/* do syntatic check.
|
|
* We break the URL into host, port, path, search
|
|
*/
|
|
port = def_port;
|
|
err = ap_proxy_canon_netloc(r->pool, &url, NULL, NULL, &host, &port);
|
|
if (err)
|
|
return HTTP_BAD_REQUEST;
|
|
|
|
/* now parse path/search args, according to rfc1738 */
|
|
/* N.B. if this isn't a true proxy request, then the URL _path_
|
|
* has already been decoded. True proxy requests have r->uri
|
|
* == r->unparsed_uri, and no others have that property.
|
|
*/
|
|
if (r->uri == r->unparsed_uri) {
|
|
search = strchr(url, '?');
|
|
if (search != NULL)
|
|
*(search++) = '\0';
|
|
}
|
|
else
|
|
search = r->args;
|
|
|
|
/* process path */
|
|
path = ap_proxy_canonenc(r->pool, url, strlen(url), enc_path, r->proxyreq);
|
|
if (path == NULL)
|
|
return HTTP_BAD_REQUEST;
|
|
|
|
if (port != def_port)
|
|
ap_snprintf(sport, sizeof(sport), ":%d", port);
|
|
else
|
|
sport[0] = '\0';
|
|
|
|
r->filename = ap_pstrcat(r->pool, "proxy:", scheme, "://", host, sport, "/",
|
|
path, (search) ? "?" : "", (search) ? search : "", NULL);
|
|
return OK;
|
|
}
|
|
|
|
static const char *proxy_location_reverse_map(request_rec *r, const char *url)
|
|
{
|
|
void *sconf;
|
|
proxy_server_conf *conf;
|
|
struct proxy_alias *ent;
|
|
int i, l1, l2;
|
|
char *u;
|
|
|
|
sconf = r->server->module_config;
|
|
conf = (proxy_server_conf *)ap_get_module_config(sconf, &proxy_module);
|
|
l1 = strlen(url);
|
|
ent = (struct proxy_alias *)conf->raliases->elts;
|
|
for (i = 0; i < conf->raliases->nelts; i++) {
|
|
l2 = strlen(ent[i].real);
|
|
if (l1 >= l2 && strncmp(ent[i].real, url, l2) == 0) {
|
|
u = ap_pstrcat(r->pool, ent[i].fake, &url[l2], NULL);
|
|
return ap_construct_url(r->pool, u, r);
|
|
}
|
|
}
|
|
return url;
|
|
}
|
|
|
|
/* Clear all connection-based headers from the incoming headers table */
|
|
static void clear_connection(pool *p, table *headers)
|
|
{
|
|
const char *name;
|
|
char *next = ap_pstrdup(p, ap_table_get(headers, "Connection"));
|
|
|
|
ap_table_unset(headers, "Proxy-Connection");
|
|
if (!next)
|
|
return;
|
|
|
|
while (*next) {
|
|
name = next;
|
|
while (*next && !ap_isspace(*next) && (*next != ','))
|
|
++next;
|
|
while (*next && (ap_isspace(*next) || (*next == ','))) {
|
|
*next = '\0';
|
|
++next;
|
|
}
|
|
ap_table_unset(headers, name);
|
|
}
|
|
ap_table_unset(headers, "Connection");
|
|
}
|
|
|
|
/*
|
|
* This handles http:// URLs, and other URLs using a remote proxy over http
|
|
* If proxyhost is NULL, then contact the server directly, otherwise
|
|
* go via the proxy.
|
|
* Note that if a proxy is used, then URLs other than http: can be accessed,
|
|
* also, if we have trouble which is clearly specific to the proxy, then
|
|
* we return DECLINED so that we can try another proxy. (Or the direct
|
|
* route.)
|
|
*/
|
|
int ap_proxy_http_handler(request_rec *r, cache_req *c, char *url,
|
|
const char *proxyhost, int proxyport)
|
|
{
|
|
const char *strp;
|
|
char *strp2;
|
|
const char *err, *desthost;
|
|
int i, j, sock, len, backasswards;
|
|
array_header *reqhdrs_arr;
|
|
table *resp_hdrs;
|
|
table_entry *reqhdrs;
|
|
struct sockaddr_in server;
|
|
struct in_addr destaddr;
|
|
struct hostent server_hp;
|
|
BUFF *f;
|
|
char buffer[HUGE_STRING_LEN];
|
|
char portstr[32];
|
|
pool *p = r->pool;
|
|
const long int zero = 0L;
|
|
int destport = 0;
|
|
char *destportstr = NULL;
|
|
const char *urlptr = NULL;
|
|
const char *datestr;
|
|
struct tbl_do_args tdo;
|
|
|
|
void *sconf = r->server->module_config;
|
|
proxy_server_conf *conf =
|
|
(proxy_server_conf *) ap_get_module_config(sconf, &proxy_module);
|
|
struct noproxy_entry *npent = (struct noproxy_entry *) conf->noproxies->elts;
|
|
struct nocache_entry *ncent = (struct nocache_entry *) conf->nocaches->elts;
|
|
int nocache = 0;
|
|
|
|
memset(&server, '\0', sizeof(server));
|
|
server.sin_family = AF_INET;
|
|
|
|
/* We break the URL into host, port, path-search */
|
|
|
|
urlptr = strstr(url, "://");
|
|
if (urlptr == NULL)
|
|
return HTTP_BAD_REQUEST;
|
|
urlptr += 3;
|
|
destport = DEFAULT_HTTP_PORT;
|
|
strp = strchr(urlptr, '/');
|
|
if (strp == NULL) {
|
|
desthost = ap_pstrdup(p, urlptr);
|
|
urlptr = "/";
|
|
}
|
|
else {
|
|
char *q = ap_palloc(p, strp - urlptr + 1);
|
|
memcpy(q, urlptr, strp - urlptr);
|
|
q[strp - urlptr] = '\0';
|
|
urlptr = strp;
|
|
desthost = q;
|
|
}
|
|
|
|
strp2 = strchr(desthost, ':');
|
|
if (strp2 != NULL) {
|
|
*(strp2++) = '\0';
|
|
if (ap_isdigit(*strp2)) {
|
|
destport = atoi(strp2);
|
|
destportstr = strp2;
|
|
}
|
|
}
|
|
|
|
/* check if ProxyBlock directive on this host */
|
|
destaddr.s_addr = ap_inet_addr(desthost);
|
|
for (i = 0; i < conf->noproxies->nelts; i++) {
|
|
if ((npent[i].name != NULL && strstr(desthost, npent[i].name) != NULL)
|
|
|| destaddr.s_addr == npent[i].addr.s_addr || npent[i].name[0] == '*')
|
|
return ap_proxyerror(r, HTTP_FORBIDDEN,
|
|
"Connect to remote machine blocked");
|
|
}
|
|
|
|
if (proxyhost != NULL) {
|
|
server.sin_port = htons(proxyport);
|
|
err = ap_proxy_host2addr(proxyhost, &server_hp);
|
|
if (err != NULL)
|
|
return DECLINED; /* try another */
|
|
}
|
|
else {
|
|
server.sin_port = htons(destport);
|
|
err = ap_proxy_host2addr(desthost, &server_hp);
|
|
if (err != NULL)
|
|
return ap_proxyerror(r, HTTP_INTERNAL_SERVER_ERROR, err);
|
|
}
|
|
|
|
sock = ap_psocket(p, PF_INET, SOCK_STREAM, IPPROTO_TCP);
|
|
if (sock == -1) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, r,
|
|
"proxy: error creating socket");
|
|
return HTTP_INTERNAL_SERVER_ERROR;
|
|
}
|
|
|
|
if (conf->recv_buffer_size) {
|
|
if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
|
|
(const char *) &conf->recv_buffer_size, sizeof(int))
|
|
== -1) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, r,
|
|
"setsockopt(SO_RCVBUF): Failed to set ProxyReceiveBufferSize, using default");
|
|
}
|
|
}
|
|
|
|
#ifdef SINIX_D_RESOLVER_BUG
|
|
{
|
|
struct in_addr *ip_addr = (struct in_addr *) *server_hp.h_addr_list;
|
|
|
|
for (; ip_addr->s_addr != 0; ++ip_addr) {
|
|
memcpy(&server.sin_addr, ip_addr, sizeof(struct in_addr));
|
|
i = ap_proxy_doconnect(sock, &server, r);
|
|
if (i == 0)
|
|
break;
|
|
}
|
|
}
|
|
#else
|
|
j = 0;
|
|
while (server_hp.h_addr_list[j] != NULL) {
|
|
memcpy(&server.sin_addr, server_hp.h_addr_list[j],
|
|
sizeof(struct in_addr));
|
|
i = ap_proxy_doconnect(sock, &server, r);
|
|
if (i == 0)
|
|
break;
|
|
j++;
|
|
}
|
|
#endif
|
|
if (i == -1) {
|
|
if (proxyhost != NULL)
|
|
return DECLINED; /* try again another way */
|
|
else
|
|
return ap_proxyerror(r, HTTP_BAD_GATEWAY, ap_pstrcat(r->pool,
|
|
"Could not connect to remote machine: ",
|
|
strerror(errno), NULL));
|
|
}
|
|
|
|
clear_connection(r->pool, r->headers_in); /* Strip connection-based headers */
|
|
|
|
f = ap_bcreate(p, B_RDWR | B_SOCKET);
|
|
ap_bpushfd(f, sock, sock);
|
|
|
|
ap_hard_timeout("proxy send", r);
|
|
ap_bvputs(f, r->method, " ", proxyhost ? url : urlptr, " HTTP/1.0" CRLF,
|
|
NULL);
|
|
if (destportstr != NULL && destport != DEFAULT_HTTP_PORT)
|
|
ap_bvputs(f, "Host: ", desthost, ":", destportstr, CRLF, NULL);
|
|
else
|
|
ap_bvputs(f, "Host: ", desthost, CRLF, NULL);
|
|
|
|
if (conf->viaopt == via_block) {
|
|
/* Block all outgoing Via: headers */
|
|
ap_table_unset(r->headers_in, "Via");
|
|
} else if (conf->viaopt != via_off) {
|
|
/* Create a "Via:" request header entry and merge it */
|
|
i = ap_get_server_port(r);
|
|
if (ap_is_default_port(i,r)) {
|
|
strcpy(portstr,"");
|
|
} else {
|
|
ap_snprintf(portstr, sizeof portstr, ":%d", i);
|
|
}
|
|
/* Generate outgoing Via: header with/without server comment: */
|
|
ap_table_mergen(r->headers_in, "Via",
|
|
(conf->viaopt == via_full)
|
|
? ap_psprintf(p, "%d.%d %s%s (%s)",
|
|
HTTP_VERSION_MAJOR(r->proto_num),
|
|
HTTP_VERSION_MINOR(r->proto_num),
|
|
ap_get_server_name(r), portstr,
|
|
SERVER_BASEVERSION)
|
|
: ap_psprintf(p, "%d.%d %s%s",
|
|
HTTP_VERSION_MAJOR(r->proto_num),
|
|
HTTP_VERSION_MINOR(r->proto_num),
|
|
ap_get_server_name(r), portstr)
|
|
);
|
|
}
|
|
|
|
reqhdrs_arr = ap_table_elts(r->headers_in);
|
|
reqhdrs = (table_entry *) reqhdrs_arr->elts;
|
|
for (i = 0; i < reqhdrs_arr->nelts; i++) {
|
|
if (reqhdrs[i].key == NULL || reqhdrs[i].val == NULL
|
|
/* Clear out headers not to send */
|
|
|| !strcasecmp(reqhdrs[i].key, "Host") /* Already sent */
|
|
/* XXX: @@@ FIXME: "Proxy-Authorization" should *only* be
|
|
* suppressed if THIS server requested the authentication,
|
|
* not when a frontend proxy requested it!
|
|
*/
|
|
|| !strcasecmp(reqhdrs[i].key, "Proxy-Authorization"))
|
|
continue;
|
|
ap_bvputs(f, reqhdrs[i].key, ": ", reqhdrs[i].val, CRLF, NULL);
|
|
}
|
|
|
|
ap_bputs(CRLF, f);
|
|
/* send the request data, if any. */
|
|
|
|
if (ap_should_client_block(r)) {
|
|
while ((i = ap_get_client_block(r, buffer, sizeof buffer)) > 0)
|
|
ap_bwrite(f, buffer, i);
|
|
}
|
|
ap_bflush(f);
|
|
ap_kill_timeout(r);
|
|
|
|
ap_hard_timeout("proxy receive", r);
|
|
|
|
len = ap_bgets(buffer, sizeof buffer - 1, f);
|
|
if (len == -1) {
|
|
ap_bclose(f);
|
|
ap_kill_timeout(r);
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, r,
|
|
"ap_bgets() - proxy receive - Error reading from remote server %s (length %d)",
|
|
proxyhost ? proxyhost : desthost, len);
|
|
return ap_proxyerror(r, HTTP_BAD_GATEWAY,
|
|
"Error reading from remote server");
|
|
} else if (len == 0) {
|
|
ap_bclose(f);
|
|
ap_kill_timeout(r);
|
|
return ap_proxyerror(r, HTTP_BAD_GATEWAY,
|
|
"Document contains no data");
|
|
}
|
|
|
|
/* Is it an HTTP/1 response? This is buggy if we ever see an HTTP/1.10 */
|
|
if (ap_checkmask(buffer, "HTTP/#.# ###*")) {
|
|
int major, minor;
|
|
if (2 != sscanf(buffer, "HTTP/%u.%u", &major, &minor)) {
|
|
major = 1;
|
|
minor = 0;
|
|
}
|
|
|
|
/* If not an HTTP/1 message or if the status line was > 8192 bytes */
|
|
if (buffer[5] != '1' || buffer[len - 1] != '\n') {
|
|
ap_bclose(f);
|
|
ap_kill_timeout(r);
|
|
return HTTP_BAD_GATEWAY;
|
|
}
|
|
backasswards = 0;
|
|
buffer[--len] = '\0';
|
|
|
|
buffer[12] = '\0';
|
|
r->status = atoi(&buffer[9]);
|
|
buffer[12] = ' ';
|
|
r->status_line = ap_pstrdup(p, &buffer[9]);
|
|
|
|
/* read the headers. */
|
|
/* N.B. for HTTP/1.0 clients, we have to fold line-wrapped headers */
|
|
/* Also, take care with headers with multiple occurences. */
|
|
|
|
resp_hdrs = ap_proxy_read_headers(r, buffer, HUGE_STRING_LEN, f);
|
|
if (resp_hdrs == NULL) {
|
|
ap_log_error(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, r->server,
|
|
"proxy: Bad HTTP/%d.%d header returned by %s (%s)",
|
|
major, minor, r->uri, r->method);
|
|
resp_hdrs = ap_make_table(p, 20);
|
|
nocache = 1; /* do not cache this broken file */
|
|
}
|
|
|
|
if (conf->viaopt != via_off && conf->viaopt != via_block) {
|
|
/* Create a "Via:" response header entry and merge it */
|
|
i = ap_get_server_port(r);
|
|
if (ap_is_default_port(i,r)) {
|
|
strcpy(portstr,"");
|
|
} else {
|
|
ap_snprintf(portstr, sizeof portstr, ":%d", i);
|
|
}
|
|
ap_table_mergen((table *)resp_hdrs, "Via",
|
|
(conf->viaopt == via_full)
|
|
? ap_psprintf(p, "%d.%d %s%s (%s)",
|
|
major, minor,
|
|
ap_get_server_name(r), portstr,
|
|
SERVER_BASEVERSION)
|
|
: ap_psprintf(p, "%d.%d %s%s",
|
|
major, minor,
|
|
ap_get_server_name(r), portstr)
|
|
);
|
|
}
|
|
|
|
clear_connection(p, resp_hdrs); /* Strip Connection hdrs */
|
|
}
|
|
else {
|
|
/* an http/0.9 response */
|
|
backasswards = 1;
|
|
r->status = 200;
|
|
r->status_line = "200 OK";
|
|
|
|
/* no headers */
|
|
resp_hdrs = ap_make_table(p, 20);
|
|
}
|
|
|
|
c->hdrs = resp_hdrs;
|
|
|
|
ap_kill_timeout(r);
|
|
|
|
/*
|
|
* HTTP/1.0 requires us to accept 3 types of dates, but only generate
|
|
* one type
|
|
*/
|
|
if ((datestr = ap_table_get(resp_hdrs, "Date")) != NULL)
|
|
ap_table_set(resp_hdrs, "Date", ap_proxy_date_canon(p, datestr));
|
|
if ((datestr = ap_table_get(resp_hdrs, "Last-Modified")) != NULL)
|
|
ap_table_set(resp_hdrs, "Last-Modified", ap_proxy_date_canon(p, datestr));
|
|
if ((datestr = ap_table_get(resp_hdrs, "Expires")) != NULL)
|
|
ap_table_set(resp_hdrs, "Expires", ap_proxy_date_canon(p, datestr));
|
|
|
|
if ((datestr = ap_table_get(resp_hdrs, "Location")) != NULL)
|
|
ap_table_set(resp_hdrs, "Location", proxy_location_reverse_map(r, datestr));
|
|
if ((datestr = ap_table_get(resp_hdrs, "URI")) != NULL)
|
|
ap_table_set(resp_hdrs, "URI", proxy_location_reverse_map(r, datestr));
|
|
|
|
/* check if NoCache directive on this host */
|
|
for (i = 0; i < conf->nocaches->nelts; i++) {
|
|
if ((ncent[i].name != NULL && strstr(desthost, ncent[i].name) != NULL)
|
|
|| destaddr.s_addr == ncent[i].addr.s_addr || ncent[i].name[0] == '*')
|
|
nocache = 1;
|
|
}
|
|
|
|
i = ap_proxy_cache_update(c, resp_hdrs, !backasswards, nocache);
|
|
if (i != DECLINED) {
|
|
ap_bclose(f);
|
|
return i;
|
|
}
|
|
|
|
ap_hard_timeout("proxy receive", r);
|
|
|
|
/* write status line */
|
|
if (!r->assbackwards)
|
|
ap_rvputs(r, "HTTP/1.0 ", r->status_line, CRLF, NULL);
|
|
if (c != NULL && c->fp != NULL &&
|
|
ap_bvputs(c->fp, "HTTP/1.0 ", r->status_line, CRLF, NULL) == -1) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, c->req,
|
|
"proxy: error writing status line to %s", c->tempfile);
|
|
c = ap_proxy_cache_error(c);
|
|
}
|
|
|
|
/* send headers */
|
|
tdo.req = r;
|
|
tdo.cache = c;
|
|
ap_table_do(ap_proxy_send_hdr_line, &tdo, resp_hdrs, NULL);
|
|
|
|
if (!r->assbackwards)
|
|
ap_rputs(CRLF, r);
|
|
if (c != NULL && c->fp != NULL && ap_bputs(CRLF, c->fp) == -1) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, c->req,
|
|
"proxy: error writing CRLF to %s", c->tempfile);
|
|
c = ap_proxy_cache_error(c);
|
|
}
|
|
|
|
ap_bsetopt(r->connection->client, BO_BYTECT, &zero);
|
|
r->sent_bodyct = 1;
|
|
/* Is it an HTTP/0.9 respose? If so, send the extra data */
|
|
if (backasswards) {
|
|
ap_bwrite(r->connection->client, buffer, len);
|
|
if (c != NULL && c->fp != NULL && ap_bwrite(c->fp, buffer, len) != len) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, c->req,
|
|
"proxy: error writing extra data to %s", c->tempfile);
|
|
c = ap_proxy_cache_error(c);
|
|
}
|
|
}
|
|
ap_kill_timeout(r);
|
|
|
|
#ifdef CHARSET_EBCDIC
|
|
/* What we read/write after the header should not be modified
|
|
* (i.e., the cache copy is ASCII, not EBCDIC, even for text/html)
|
|
*/
|
|
ap_bsetflag(f, B_ASCII2EBCDIC|B_EBCDIC2ASCII, 0);
|
|
ap_bsetflag(r->connection->client, B_ASCII2EBCDIC|B_EBCDIC2ASCII, 0);
|
|
#endif
|
|
|
|
/* send body */
|
|
/* if header only, then cache will be NULL */
|
|
/* HTTP/1.0 tells us to read to EOF, rather than content-length bytes */
|
|
if (!r->header_only) {
|
|
/* we need to set this for ap_proxy_send_fb()... */
|
|
c->cache_completion = conf->cache.cache_completion;
|
|
ap_proxy_send_fb(f, r, c);
|
|
}
|
|
|
|
ap_proxy_cache_tidy(c);
|
|
|
|
ap_bclose(f);
|
|
|
|
ap_proxy_garbage_coll(r);
|
|
return OK;
|
|
}
|