/* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include "mod_proxy.h"

#include "mod_core.h"

#include "apr_optional.h"

#include "scoreboard.h"

#include "mod_status.h"

#if (MODULE_MAGIC_NUMBER_MAJOR > 20020903)

#include "mod_ssl.h"

#else

APR_DECLARE_OPTIONAL_FN(int, ssl_proxy_enable, (conn_rec *));

APR_DECLARE_OPTIONAL_FN(int, ssl_engine_disable, (conn_rec *));

APR_DECLARE_OPTIONAL_FN(int, ssl_is_https, (conn_rec *));

APR_DECLARE_OPTIONAL_FN(char *, ssl_var_lookup,

(apr_pool_t *, server_rec *,

conn_rec *, request_rec *, char *));

#endif

#ifndef MAX

#define MAX(x,y) ((x) >= (y) ? (x) : (y))

#endif

/*

* A Web proxy module. Stages:

*

* translate_name: set filename to proxy:<URL>

* map_to_storage: run proxy_walk (rather than directory_walk/file_walk)

* can't trust directory_walk/file_walk since these are

* not in our filesystem. Prevents mod_http from serving

* the TRACE request we will set aside to handle later.

* type_checker: set type to PROXY_MAGIC_TYPE if filename begins proxy:

* fix_ups: convert the URL stored in the filename to the

* canonical form.

* handler: handle proxy requests

*/

/* -------------------------------------------------------------- */

/* Translate the URL into a 'filename' */

static const char *set_worker_param(apr_pool_t *p,

proxy_worker *worker,

const char *key,

const char *val)

{

int ival;

apr_interval_time_t timeout;

if (!strcasecmp(key, "loadfactor")) {

/* Normalized load factor. Used with BalancerMamber,

* it is a number between 1 and 100.

*/

worker->s->lbfactor = atoi(val);

if (worker->s->lbfactor < 1 || worker->s->lbfactor > 100)

return "LoadFactor must be a number between 1..100";

}

else if (!strcasecmp(key, "retry")) {

/* If set it will give the retry timeout for the worker

* The default value is 60 seconds, meaning that if

* in error state, it will be retried after that timeout.

*/

ival = atoi(val);

if (ival < 0)

return "Retry must be a positive value";

worker->s->retry = apr_time_from_sec(ival);

worker->s->retry_set = 1;

}

else if (!strcasecmp(key, "ttl")) {

/* Time in seconds that will destroy all the connections

* that exceed the smax

*/

ival = atoi(val);

if (ival < 1)

return "TTL must be at least one second";

worker->s->ttl = apr_time_from_sec(ival);

}

else if (!strcasecmp(key, "min")) {

/* Initial number of connections to remote

*/

ival = atoi(val);

if (ival < 0)

return "Min must be a positive number";

worker->s->min = ival;

}

else if (!strcasecmp(key, "max")) {

/* Maximum number of connections to remote

*/

ival = atoi(val);

if (ival < 0)

return "Max must be a positive number";

worker->s->hmax = ival;

}

/* XXX: More inteligent naming needed */

else if (!strcasecmp(key, "smax")) {

/* Maximum number of connections to remote that

* will not be destroyed

*/

ival = atoi(val);

if (ival < 0)

return "Smax must be a positive number";

worker->s->smax = ival;

}

else if (!strcasecmp(key, "acquire")) {

/* Acquire timeout in given unit (default is milliseconds).

* If set this will be the maximum time to

* wait for a free connection.

*/

if (ap_timeout_parameter_parse(val, &timeout, "ms") != APR_SUCCESS)

return "Acquire timeout has wrong format";

if (timeout < 1000)

return "Acquire must be at least one millisecond";

worker->s->acquire = timeout;

worker->s->acquire_set = 1;

}

else if (!strcasecmp(key, "timeout")) {

/* Connection timeout in seconds.

* Defaults to server timeout.

*/

ival = atoi(val);

if (ival < 1)

return "Timeout must be at least one second";

worker->s->timeout = apr_time_from_sec(ival);

worker->s->timeout_set = 1;

}

else if (!strcasecmp(key, "iobuffersize")) {

long s = atol(val);

if (s < 512 && s) {

return "IOBufferSize must be >= 512 bytes, or 0 for system default.";

}

worker->s->io_buffer_size = (s ? s : AP_IOBUFSIZE);

worker->s->io_buffer_size_set = 1;

}

else if (!strcasecmp(key, "receivebuffersize")) {

ival = atoi(val);

if (ival < 512 && ival != 0) {

return "ReceiveBufferSize must be >= 512 bytes, or 0 for system default.";

}

worker->s->recv_buffer_size = ival;

worker->s->recv_buffer_size_set = 1;

}

else if (!strcasecmp(key, "keepalive")) {

if (!strcasecmp(val, "on"))

worker->s->keepalive = 1;

else if (!strcasecmp(val, "off"))

worker->s->keepalive = 0;

else

return "KeepAlive must be On|Off";

worker->s->keepalive_set = 1;

}

else if (!strcasecmp(key, "disablereuse")) {

if (!strcasecmp(val, "on"))

worker->s->disablereuse = 1;

else if (!strcasecmp(val, "off"))

worker->s->disablereuse = 0;

else

return "DisableReuse must be On|Off";

worker->s->disablereuse_set = 1;

}

else if (!strcasecmp(key, "route")) {

/* Worker route.

*/

if (strlen(val) >= PROXY_WORKER_MAX_ROUTE_SIZE)

return "Route length must be < 64 characters";

PROXY_STRNCPY(worker->s->route, val);

}

else if (!strcasecmp(key, "redirect")) {

/* Worker redirection route.

*/

if (strlen(val) >= PROXY_WORKER_MAX_ROUTE_SIZE)

return "Redirect length must be < 64 characters";

PROXY_STRNCPY(worker->s->redirect, val);

}

else if (!strcasecmp(key, "status")) {

const char *v;

int mode = 1;

apr_status_t rv;

/* Worker status.

*/

for (v = val; *v; v++) {

if (*v == '+') {

mode = 1;

v++;

}

else if (*v == '-') {

mode = 0;

v++;

}

rv = ap_proxy_set_wstatus(*v, mode, worker);

if (rv != APR_SUCCESS)

return "Unknown status parameter option";

}

}

else if (!strcasecmp(key, "flushpackets")) {

if (!strcasecmp(val, "on"))

worker->s->flush_packets = flush_on;

else if (!strcasecmp(val, "off"))

worker->s->flush_packets = flush_off;

else if (!strcasecmp(val, "auto"))

worker->s->flush_packets = flush_auto;

else

return "flushpackets must be on|off|auto";

}

else if (!strcasecmp(key, "flushwait")) {

ival = atoi(val);

if (ival > 1000 || ival < 0) {

return "flushwait must be <= 1000, or 0 for system default of 10 millseconds.";

}

if (ival == 0)

worker->s->flush_wait = PROXY_FLUSH_WAIT;

else

worker->s->flush_wait = ival * 1000; /* change to microseconds */

}

else if (!strcasecmp(key, "ping")) {

/* Ping/Pong timeout in given unit (default is second).

*/

if (ap_timeout_parameter_parse(val, &timeout, "s") != APR_SUCCESS)

return "Ping/Pong timeout has wrong format";

if (timeout < 1000)

return "Ping/Pong timeout must be at least one millisecond";

worker->s->ping_timeout = timeout;

worker->s->ping_timeout_set = 1;

}

else if (!strcasecmp(key, "lbset")) {

ival = atoi(val);

if (ival < 0 || ival > 99)

return "lbset must be between 0 and 99";

worker->s->lbset = ival;

}

else if (!strcasecmp(key, "connectiontimeout")) {

/* Request timeout in given unit (default is second).

* Defaults to connection timeout

*/

if (ap_timeout_parameter_parse(val, &timeout, "s") != APR_SUCCESS)

return "Connectiontimeout has wrong format";

if (timeout < 1000)

return "Connectiontimeout must be at least one millisecond.";

worker->s->conn_timeout = timeout;

worker->s->conn_timeout_set = 1;

}

else if (!strcasecmp(key, "flusher")) {

if (strlen(val) >= PROXY_WORKER_MAX_SCHEME_SIZE)

return "flusher name length must be < 16 characters";

PROXY_STRNCPY(worker->s->flusher, val);

}

else {

return "unknown Worker parameter";

}

return NULL;

}

static const char *set_balancer_param(proxy_server_conf *conf,

apr_pool_t *p,

proxy_balancer *balancer,

const char *key,

const char *val)

{

int ival;

if (!strcasecmp(key, "stickysession")) {

char *path;

/* Balancer sticky session name.

* Set to something like JSESSIONID or

* PHPSESSIONID, etc..,

*/

if (strlen(val) > (PROXY_BALANCER_MAX_STICKY_SIZE-1))

return "stickysession length must be < 64 characters";

PROXY_STRNCPY(balancer->s->sticky_path, val);

PROXY_STRNCPY(balancer->s->sticky, val);

if ((path = strchr((char *)balancer->s->sticky, '|'))) {

*path++ = '\0';

PROXY_STRNCPY(balancer->s->sticky_path, path);

}

}

else if (!strcasecmp(key, "nofailover")) {

/* If set to 'on' the session will break

* if the worker is in error state or

* disabled.

*/

if (!strcasecmp(val, "on"))

balancer->s->sticky_force = 1;

else if (!strcasecmp(val, "off"))

balancer->s->sticky_force = 0;

else

return "failover must be On|Off";

}

else if (!strcasecmp(key, "timeout")) {

/* Balancer timeout in seconds.

* If set this will be the maximum time to

* wait for a free worker.

* Default is not to wait.

*/

ival = atoi(val);

if (ival < 1)

return "timeout must be at least one second";

balancer->s->timeout = apr_time_from_sec(ival);

}

else if (!strcasecmp(key, "maxattempts")) {

/* Maximum number of failover attempts before

* giving up.

*/

ival = atoi(val);

if (ival < 0)

return "maximum number of attempts must be a positive number";

balancer->s->max_attempts = ival;

balancer->s->max_attempts_set = 1;

}

else if (!strcasecmp(key, "lbmethod")) {

proxy_balancer_method *provider;

if (strlen(val) > (sizeof(balancer->s->lbpname)-1))

return "unknown lbmethod";

provider = ap_lookup_provider(PROXY_LBMETHOD, val, "0");

if (provider) {

balancer->lbmethod = provider;

PROXY_STRNCPY(balancer->s->lbpname, val);

return NULL;

}

return "unknown lbmethod";

}

else if (!strcasecmp(key, "scolonpathdelim")) {

/* If set to 'on' then ';' will also be

* used as a session path separator/delim (ala

* mod_jk)

*/

if (!strcasecmp(val, "on"))

balancer->s->scolonsep = 1;

else if (!strcasecmp(val, "off"))

balancer->s->scolonsep = 0;

else

return "scolonpathdelim must be On|Off";

}

else if (!strcasecmp(key, "failonstatus")) {

char *val_split;

char *status;

char *tok_state;

val_split = apr_pstrdup(p, val);

balancer->errstatuses = apr_array_make(p, 1, sizeof(int));

status = apr_strtok(val_split, ", ", &tok_state);

while (status != NULL) {

ival = atoi(status);

if (ap_is_HTTP_VALID_RESPONSE(ival)) {

*(int *)apr_array_push(balancer->errstatuses) = ival;

}

else {

return "failonstatus must be one or more HTTP response codes";

}

status = apr_strtok(NULL, ", ", &tok_state);

}

}

else if (!strcasecmp(key, "nonce")) {

if (!strcasecmp(val, "None")) {

*balancer->s->nonce = '\0';

}

else {

if (strlen(val) > sizeof(balancer->s->nonce)-1) {

return "Provided nonce is too large";

}

else {

PROXY_STRNCPY(balancer->s->nonce, val);

}

}

}

else if (!strcasecmp(key, "growth")) {

ival = atoi(val);

if (ival < 1 || ival > 100) /* arbitrary limit here */

return "growth must be between 1 and 100";

balancer->growth = ival;

}

else {

return "unknown Balancer parameter";

}

return NULL;

}

static int alias_match(const char *uri, const char *alias_fakename)

{

const char *end_fakename = alias_fakename + strlen(alias_fakename);

const char *aliasp = alias_fakename, *urip = uri;

const char *end_uri = uri + strlen(uri);

while (aliasp < end_fakename && urip < end_uri) {

if (*aliasp == '/') {

/* any number of '/' in the alias matches any number in

* the supplied URI, but there must be at least one...

*/

if (*urip != '/')

return 0;

while (*aliasp == '/')

++aliasp;

while (*urip == '/')

++urip;

}

else {

/* Other characters are compared literally */

if (*urip++ != *aliasp++)

return 0;

}

}

/* fixup badly encoded stuff (e.g. % as last character) */

if (aliasp > end_fakename) {

aliasp = end_fakename;

}

if (urip > end_uri) {

urip = end_uri;

}

/* We reach the end of the uri before the end of "alias_fakename"

* for example uri is "/" and alias_fakename "/examples"

*/

if (urip == end_uri && aliasp != end_fakename) {

return 0;

}

/* Check last alias path component matched all the way */

if (aliasp[-1] != '/' && *urip != '\0' && *urip != '/')

return 0;

/* Return number of characters from URI which matched (may be

* greater than length of alias, since we may have matched

* doubled slashes)

*/

return urip - uri;

}

/* Detect if an absoluteURI should be proxied or not. Note that we

* have to do this during this phase because later phases are

* "short-circuiting"... i.e. translate_names will end when the first

* module returns OK. So for example, if the request is something like:

*

* GET http://othervhost/cgi-bin/printenv HTTP/1.0

*

* mod_alias will notice the /cgi-bin part and ScriptAlias it and

* short-circuit the proxy... just because of the ordering in the

* configuration file.

*/

static int proxy_detect(request_rec *r)

{

void *sconf = r->server->module_config;

proxy_server_conf *conf =

(proxy_server_conf *) ap_get_module_config(sconf, &proxy_module);

/* Ick... msvc (perhaps others) promotes ternary short results to int */

if (conf->req && r->parsed_uri.scheme) {

/* but it might be something vhosted */

if (!(r->parsed_uri.hostname

&& !strcasecmp(r->parsed_uri.scheme, ap_http_scheme(r))

&& ap_matches_request_vhost(r, r->parsed_uri.hostname,

(apr_port_t)(r->parsed_uri.port_str ? r->parsed_uri.port

: ap_default_port(r))))) {

r->proxyreq = PROXYREQ_PROXY;

r->uri = r->unparsed_uri;

r->filename = apr_pstrcat(r->pool, "proxy:", r->uri, NULL);

r->handler = "proxy-server";

}

}

/* We need special treatment for CONNECT proxying: it has no scheme part */

else if (conf->req && r->method_number == M_CONNECT

&& r->parsed_uri.hostname

&& r->parsed_uri.port_str) {

r->proxyreq = PROXYREQ_PROXY;

r->uri = r->unparsed_uri;

r->filename = apr_pstrcat(r->pool, "proxy:", r->uri, NULL);

r->handler = "proxy-server";

}

return DECLINED;

}

static const char *proxy_interpolate(request_rec *r, const char *str)

{

/* Interpolate an env str in a configuration string

* Syntax ${var} --> value_of(var)

* Method: replace one var, and recurse on remainder of string

* Nothing clever here, and crap like nested vars may do silly things

* but we'll at least avoid sending the unwary into a loop

*/

const char *start;

const char *end;

const char *var;

const char *val;

const char *firstpart;

start = ap_strstr_c(str, "${");

if (start == NULL) {

return str;

}

end = ap_strchr_c(start+2, '}');

if (end == NULL) {

return str;

}

/* OK, this is syntax we want to interpolate. Is there such a var ? */

var = apr_pstrndup(r->pool, start+2, end-(start+2));

val = apr_table_get(r->subprocess_env, var);

firstpart = apr_pstrndup(r->pool, str, (start-str));

if (val == NULL) {

return apr_pstrcat(r->pool, firstpart,

proxy_interpolate(r, end+1), NULL);

}

else {

return apr_pstrcat(r->pool, firstpart, val,

proxy_interpolate(r, end+1), NULL);

}

}

static apr_array_header_t *proxy_vars(request_rec *r,

apr_array_header_t *hdr)

{

int i;

apr_array_header_t *ret = apr_array_make(r->pool, hdr->nelts,

sizeof (struct proxy_alias));

struct proxy_alias *old = (struct proxy_alias *) hdr->elts;

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

struct proxy_alias *newcopy = apr_array_push(ret);

newcopy->fake = (old[i].flags & PROXYPASS_INTERPOLATE)

? proxy_interpolate(r, old[i].fake) : old[i].fake;

newcopy->real = (old[i].flags & PROXYPASS_INTERPOLATE)

? proxy_interpolate(r, old[i].real) : old[i].real;

}

return ret;

}

PROXY_DECLARE(int) ap_proxy_trans_match(request_rec *r, struct proxy_alias *ent,

proxy_dir_conf *dconf)

{

int len;

const char *fake;

const char *real;

ap_regmatch_t regm[AP_MAX_REG_MATCH];

ap_regmatch_t reg1[AP_MAX_REG_MATCH];

char *found = NULL;

int mismatch = 0;

unsigned int nocanon = ent->flags & PROXYPASS_NOCANON;

const char *use_uri = nocanon ? r->unparsed_uri : r->uri;

if (dconf && (dconf->interpolate_env == 1) && (ent->flags & PROXYPASS_INTERPOLATE)) {

fake = proxy_interpolate(r, ent->fake);

real = proxy_interpolate(r, ent->real);

}

else {

fake = ent->fake;

real = ent->real;

}

if (ent->regex) {

if (!ap_regexec(ent->regex, r->uri, AP_MAX_REG_MATCH, regm, 0)) {

if ((real[0] == '!') && (real[1] == '\0')) {

return DECLINED;

}

/* test that we haven't reduced the URI */

if (nocanon && ap_regexec(ent->regex, r->unparsed_uri,

AP_MAX_REG_MATCH, reg1, 0)) {

mismatch = 1;

use_uri = r->uri;

}

found = ap_pregsub(r->pool, real, use_uri, AP_MAX_REG_MATCH,

(use_uri == r->uri) ? regm : reg1);

if (!found) {

ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r,

"Substitution in regular expression failed. "

"Replacement too long?");

return HTTP_INTERNAL_SERVER_ERROR;

}

/* Note: The strcmp() below catches cases where there

* was no regex substitution. This is so cases like:

*

* ProxyPassMatch \.gif balancer://foo

*

* will work "as expected". The upshot is that the 2

* directives below act the exact same way (ie: $1 is implied):

*

* ProxyPassMatch ^(/.*\.gif)$ balancer://foo

* ProxyPassMatch ^(/.*\.gif)$ balancer://foo$1

*

* which may be confusing.

*/

if (strcmp(found, real) != 0) {

found = apr_pstrcat(r->pool, "proxy:", found, NULL);

}

else {

found = apr_pstrcat(r->pool, "proxy:", real, use_uri, NULL);

}

}

}

else {

len = alias_match(r->uri, fake);

if (len != 0) {

if ((real[0] == '!') && (real[1] == '\0')) {

return DECLINED;

}

if (nocanon && len != alias_match(r->unparsed_uri, ent->fake)) {

mismatch = 1;

use_uri = r->uri;

}

found = apr_pstrcat(r->pool, "proxy:", real, use_uri + len, NULL);

}

}

if (mismatch) {

/* We made a reducing transformation, so we can't safely use

* unparsed_uri. Safe fallback is to ignore nocanon.

*/

ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r,

"Unescaped URL path matched ProxyPass; ignoring unsafe nocanon");

}

if (found) {

r->filename = found;

r->handler = "proxy-server";

r->proxyreq = PROXYREQ_REVERSE;

if (nocanon && !mismatch) {

/* mod_proxy_http needs to be told. Different module. */

apr_table_setn(r->notes, "proxy-nocanon", "1");

}

return OK;

}

return DONE;

}

static int proxy_trans(request_rec *r)

{

int i;

struct proxy_alias *ent;

proxy_dir_conf *dconf;

proxy_server_conf *conf;

if (r->proxyreq) {

/* someone has already set up the proxy, it was possibly ourselves

* in proxy_detect

*/

return OK;

}

/* XXX: since r->uri has been manipulated already we're not really

* compliant with RFC1945 at this point. But this probably isn't

* an issue because this is a hybrid proxy/origin server.

*/

dconf = ap_get_module_config(r->per_dir_config, &proxy_module);

/* short way - this location is reverse proxied? */

if (dconf->alias) {

int rv = ap_proxy_trans_match(r, dconf->alias, dconf);

if (DONE != rv) {

return rv;

}

}

conf

= (proxy_server_conf *) ap_get_module_config(r->server->module_config, &proxy_module);

/* long way - walk the list of aliases, find a match */

if (conf->aliases->nelts) {

ent = (struct proxy_alias *) conf->aliases->elts;

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

int rv = ap_proxy_trans_match(r, &ent[i], dconf);

if (DONE != rv) {

return rv;

}

}

}

return DECLINED;

}

static int proxy_walk(request_rec *r)

{

proxy_server_conf *sconf = ap_get_module_config(r->server->module_config,

&proxy_module);

ap_conf_vector_t *per_dir_defaults = r->server->lookup_defaults;

ap_conf_vector_t **sec_proxy = (ap_conf_vector_t **) sconf->sec_proxy->elts;

ap_conf_vector_t *entry_config;

proxy_dir_conf *entry_proxy;

int num_sec = sconf->sec_proxy->nelts;

/* XXX: shouldn't we use URI here? Canonicalize it first?

* Pass over "proxy:" prefix

*/

const char *proxyname = r->filename + 6;

int j;

for (j = 0; j < num_sec; ++j)

{

entry_config = sec_proxy[j];

entry_proxy = ap_get_module_config(entry_config, &proxy_module);

/* XXX: What about case insensitive matching ???

* Compare regex, fnmatch or string as appropriate

* If the entry doesn't relate, then continue

*/

if (entry_proxy->r

? ap_regexec(entry_proxy->r, proxyname, 0, NULL, 0)

: (entry_proxy->p_is_fnmatch

? apr_fnmatch(entry_proxy->p, proxyname, 0)

: strncmp(proxyname, entry_proxy->p,

strlen(entry_proxy->p)))) {

continue;

}

per_dir_defaults = ap_merge_per_dir_configs(r->pool, per_dir_defaults,

entry_config);

}

r->per_dir_config = per_dir_defaults;

return OK;

}

static int proxy_map_location(request_rec *r)

{

int access_status;

if (!r->proxyreq || !r->filename || strncmp(r->filename, "proxy:", 6) != 0)

return DECLINED;

/* Don't let the core or mod_http map_to_storage hooks handle this,

* We don't need directory/file_walk, and we want to TRACE on our own.

*/

if ((access_status = proxy_walk(r))) {

ap_die(access_status, r);

return access_status;

}

return OK;

}

/* -------------------------------------------------------------- */

/* Fixup the filename */

/*

* Canonicalise the URL

*/

static int proxy_fixup(request_rec *r)

{

char *url, *p;

int access_status;

proxy_dir_conf *dconf = ap_get_module_config(r->per_dir_config,

&proxy_module);

if (!r->proxyreq || !r->filename || strncmp(r->filename, "proxy:", 6) != 0)

return DECLINED;

/* XXX: Shouldn't we try this before we run the proxy_walk? */

url = &r->filename[6];

if ((dconf->interpolate_env == 1) && (r->proxyreq == PROXYREQ_REVERSE)) {

/* create per-request copy of reverse proxy conf,

* and interpolate vars in it

*/

proxy_req_conf *rconf = apr_palloc(r->pool, sizeof(proxy_req_conf));

ap_set_module_config(r->request_config, &proxy_module, rconf);

rconf->raliases = proxy_vars(r, dconf->raliases);

rconf->cookie_paths = proxy_vars(r, dconf->cookie_paths);

rconf->cookie_domains = proxy_vars(r, dconf->cookie_domains);

}

/* canonicalise each specific scheme */

if ((access_status = proxy_run_canon_handler(r, url))) {

return access_status;

}

p = strchr(url, ':');

if (p == NULL || p == url)

return HTTP_BAD_REQUEST;

return OK; /* otherwise; we've done the best we can */

}

/* Send a redirection if the request contains a hostname which is not */

/* fully qualified, i.e. doesn't have a domain name appended. Some proxy */

/* servers like Netscape's allow this and access hosts from the local */

/* domain in this case. I think it is better to redirect to a FQDN, since */

/* these will later be found in the bookmarks files. */

/* The "ProxyDomain" directive determines what domain will be appended */

static int proxy_needsdomain(request_rec *r, const char *url, const char *domain)

{

char *nuri;

const char *ref;

/* We only want to worry about GETs */

if (!r->proxyreq || r->method_number != M_GET || !r->parsed_uri.hostname)

return DECLINED;

/* If host does contain a dot already, or it is "localhost", decline */

if (strchr(r->parsed_uri.hostname, '.') != NULL /* has domain, or IPv4 literal */

|| strchr(r->parsed_uri.hostname, ':') != NULL /* IPv6 literal */

|| strcasecmp(r->parsed_uri.hostname, "localhost") == 0)

return DECLINED; /* host name has a dot already */

ref = apr_table_get(r->headers_in, "Referer");

/* Reassemble the request, but insert the domain after the host name */

/* Note that the domain name always starts with a dot */

r->parsed_uri.hostname = apr_pstrcat(r->pool, r->parsed_uri.hostname,

domain, NULL);

nuri = apr_uri_unparse(r->pool,

&r->parsed_uri,

APR_URI_UNP_REVEALPASSWORD);

apr_table_setn(r->headers_out, "Location", nuri);

ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r,

"Domain missing: %s sent to %s%s%s", r->uri,

apr_uri_unparse(r->pool, &r->parsed_uri,

APR_URI_UNP_OMITUSERINFO),

ref ? " from " : "", ref ? ref : "");

return HTTP_MOVED_PERMANENTLY;

}

/* -------------------------------------------------------------- */

/* Invoke handler */

static int proxy_handler(request_rec *r)

{

char *uri, *scheme, *p;

const char *p2;

void *sconf = r->server->module_config;

proxy_server_conf *conf = (proxy_server_conf *)

ap_get_module_config(sconf, &proxy_module);

apr_array_header_t *proxies = conf->proxies;

struct proxy_remote *ents = (struct proxy_remote *) proxies->elts;

int i, rc, access_status;

int direct_connect = 0;

const char *str;

long maxfwd;

proxy_balancer *balancer = NULL;

proxy_worker *worker = NULL;

int attempts = 0, max_attempts = 0;

struct dirconn_entry *list = (struct dirconn_entry *)conf->dirconn->elts;

/* is this for us? */

if (!r->proxyreq || !r->filename || strncmp(r->filename, "proxy:", 6) != 0)

return DECLINED;

/* handle max-forwards / OPTIONS / TRACE */

if ((str = apr_table_get(r->headers_in, "Max-Forwards"))) {

maxfwd = strtol(str, NULL, 10);

if (maxfwd < 1) {

switch (r->method_number) {

case M_TRACE: {

int access_status;

r->proxyreq = PROXYREQ_NONE;

if ((access_status = ap_send_http_trace(r)))

ap_die(access_status, r);

else

ap_finalize_request_protocol(r);

return OK;

}

case M_OPTIONS: {

int access_status;

r->proxyreq = PROXYREQ_NONE;

if ((access_status = ap_send_http_options(r)))

ap_die(access_status, r);

else

ap_finalize_request_protocol(r);

return OK;

}

default: {

return ap_proxyerror(r, HTTP_BAD_GATEWAY,

"Max-Forwards has reached zero - proxy loop?");

}

}

}

maxfwd = (maxfwd > 0) ? maxfwd - 1 : 0;

}

else {

/* set configured max-forwards */

maxfwd = conf->maxfwd;

}

if (maxfwd >= 0) {

apr_table_setn(r->headers_in, "Max-Forwards",

apr_psprintf(r->pool, "%ld", maxfwd));

}

if (r->method_number == M_TRACE) {

core_server_config *coreconf = (core_server_config *)

ap_get_core_module_config(sconf);

if (coreconf->trace_enable == AP_TRACE_DISABLE)

{

/* Allow "error-notes" string to be printed by ap_send_error_response()

* Note; this goes nowhere, canned error response need an overhaul.

*/

apr_table_setn(r->notes, "error-notes",

"TRACE forbidden by server configuration");

apr_table_setn(r->notes, "verbose-error-to", "*");

ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,

"proxy: TRACE forbidden by server configuration");

return HTTP_METHOD_NOT_ALLOWED;

}

/* Can't test ap_should_client_block, we aren't ready to send

* the client a 100 Continue response till the connection has

* been established

*/

if (coreconf->trace_enable != AP_TRACE_EXTENDED

&& (r->read_length || r->read_chunked || r->remaining))

{

/* Allow "error-notes" string to be printed by ap_send_error_response()

* Note; this goes nowhere, canned error response need an overhaul.

*/

apr_table_setn(r->notes, "error-notes",

"TRACE with request body is not allowed");

apr_table_setn(r->notes, "verbose-error-to", "*");

ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,

"proxy: TRACE with request body is not allowed");

return HTTP_REQUEST_ENTITY_TOO_LARGE;

}

}

uri = r->filename + 6;

p = strchr(uri, ':');

if (p == NULL) {

ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,

"proxy_handler no URL in %s", r->filename);

return HTTP_BAD_REQUEST;

}

/* If the host doesn't have a domain name, add one and redirect. */

if (conf->domain != NULL) {

rc = proxy_needsdomain(r, uri, conf->domain);

if (ap_is_HTTP_REDIRECT(rc))

return HTTP_MOVED_PERMANENTLY;

}

scheme = apr_pstrndup(r->pool, uri, p - uri);

/* Check URI's destination host against NoProxy hosts */

/* Bypass ProxyRemote server lookup if configured as NoProxy */

for (direct_connect = i = 0; i < conf->dirconn->nelts &&

!direct_connect; i++) {

direct_connect = list[i].matcher(&list[i], r);

}

#if DEBUGGING

ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,

(direct_connect) ? "NoProxy for %s" : "UseProxy for %s",

r->uri);

#endif

do {

char *url = uri;

/* Try to obtain the most suitable worker */

access_status = ap_proxy_pre_request(&worker, &balancer, r, conf, &url);

if (access_status != OK) {

/*

* Only return if access_status is not HTTP_SERVICE_UNAVAILABLE

* This gives other modules the chance to hook into the

* request_status hook and decide what to do in this situation.

*/

if (access_status != HTTP_SERVICE_UNAVAILABLE)

return access_status;

/*

* Ensure that balancer is NULL if worker is NULL to prevent

* potential problems in the post_request hook.

*/

if (!worker)

balancer = NULL;

goto cleanup;

}

/* Initialise worker if needed, note the shared area must be initialized by the balancer logic */

if (balancer) {

ap_proxy_initialize_worker(worker, r->server, conf->pool);

}

if (balancer && balancer->s->max_attempts_set && !max_attempts)

max_attempts = balancer->s->max_attempts;

/* firstly, try a proxy, unless a NoProxy directive is active */

if (!direct_connect) {

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

p2 = ap_strchr_c(ents[i].scheme, ':'); /* is it a partial URL? */

if (strcmp(ents[i].scheme, "*") == 0 ||

(ents[i].use_regex &&

ap_regexec(ents[i].regexp, url, 0, NULL, 0) == 0) ||

(p2 == NULL && strcasecmp(scheme, ents[i].scheme) == 0) ||

(p2 != NULL &&

strncasecmp(url, ents[i].scheme,

strlen(ents[i].scheme)) == 0)) {

/* handle the scheme */

ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,

"Trying to run scheme_handler against proxy");