proxy_util.c revision a652b68dea502131f70084ead7981d5fc754cd34
2d2eda71267231c2526be701fe655db125852c1ffielding/* Licensed to the Apache Software Foundation (ASF) under one or more
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * contributor license agreements. See the NOTICE file distributed with
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * this work for additional information regarding copyright ownership.
bc8fd1b0b1afdf89b8d28eefa8cd74e26ba97986fielding * The ASF licenses this file to You under the Apache License, Version 2.0
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * (the "License"); you may not use this file except in compliance with
2d2eda71267231c2526be701fe655db125852c1ffielding * the License. You may obtain a copy of the License at
2d2eda71267231c2526be701fe655db125852c1ffielding * Unless required by applicable law or agreed to in writing, software
2d2eda71267231c2526be701fe655db125852c1ffielding * distributed under the License is distributed on an "AS IS" BASIS,
2d2eda71267231c2526be701fe655db125852c1ffielding * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2d2eda71267231c2526be701fe655db125852c1ffielding * See the License for the specific language governing permissions and
2d2eda71267231c2526be701fe655db125852c1ffielding * limitations under the License.
2d2eda71267231c2526be701fe655db125852c1ffielding/* Utility routines for Apache proxy */
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * Opaque structure containing target server info when
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * using a forward proxy.
f062ed7bd262a37a909dd77ce5fc23b446818823fielding * Up to now only used in combination with HTTP CONNECT.
f062ed7bd262a37a909dd77ce5fc23b446818823fieldingtypedef struct {
f062ed7bd262a37a909dd77ce5fc23b446818823fielding int use_http_connect; /* Use SSL Tunneling via HTTP CONNECT */
2d2eda71267231c2526be701fe655db125852c1ffielding/* Global balancer counter */
2d2eda71267231c2526be701fe655db125852c1ffieldingstatic int lb_workers_limit = 0;
f062ed7bd262a37a909dd77ce5fc23b446818823fieldingstatic int proxy_match_ipaddr(struct dirconn_entry *This, request_rec *r);
f062ed7bd262a37a909dd77ce5fc23b446818823fieldingstatic int proxy_match_domainname(struct dirconn_entry *This, request_rec *r);
2d2eda71267231c2526be701fe655db125852c1ffieldingstatic int proxy_match_hostname(struct dirconn_entry *This, request_rec *r);
f062ed7bd262a37a909dd77ce5fc23b446818823fieldingstatic int proxy_match_word(struct dirconn_entry *This, request_rec *r);
f062ed7bd262a37a909dd77ce5fc23b446818823fieldingAPR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(proxy, PROXY, int, create_req,
2d2eda71267231c2526be701fe655db125852c1ffielding/* already called in the knowledge that the characters are hex digits */
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb int ch = x[0];
61fd0cab072a05b855cbef9c585702401ac5ae29rbb#else /*APR_CHARSET_EBCDIC*/
2d2eda71267231c2526be701fe655db125852c1ffielding * we assume that the hex value refers to an ASCII character
2d2eda71267231c2526be701fe655db125852c1ffielding * so convert to EBCDIC so that it makes sense locally;
8af88bd6958b80c224e964892b8237720b13ab1ajerenkrantz * client specifies %20 in URL to refer to a space char;
8af88bd6958b80c224e964892b8237720b13ab1ajerenkrantz * at this point we're called with EBCDIC "20"; after turning
8af88bd6958b80c224e964892b8237720b13ab1ajerenkrantz * EBCDIC "20" into binary 0x20, we then need to assume that 0x20
bfb62a96023822c56c9120e4ee627d4091cc59c2rbb * represents an ASCII char and convert 0x20 to EBCDIC, yielding
3d96ee83babeec32482c9082c9426340cee8c44dwrowe return buf[0];
61fd0cab072a05b855cbef9c585702401ac5ae29rbb#endif /*APR_CHARSET_EBCDIC*/
2d2eda71267231c2526be701fe655db125852c1ffielding x[0] = '%';
2d2eda71267231c2526be701fe655db125852c1ffielding if (i >= 10) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (i >= 10) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb#else /*APR_CHARSET_EBCDIC*/
61fd0cab072a05b855cbef9c585702401ac5ae29rbb x[0] = '%';
61fd0cab072a05b855cbef9c585702401ac5ae29rbb#endif /*APR_CHARSET_EBCDIC*/
7bdef86e15d47d16dcbe7a5611683191774bd5fbgstein * canonicalise a URL-encoded string
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * Convert a URL-encoded string to canonical form.
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * It decodes characters which need not be encoded,
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * and encodes those which must be encoded, and does not touch
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * those which must not be touched.
c9a95767fbf0f5fb0976a06b97a256033925e433rbbPROXY_DECLARE(char *)ap_proxy_canonenc(apr_pool_t *p, const char *x, int len,
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp int i, j, ch;
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp char *allowed; /* characters which should not be encoded */
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp char *reserved; /* characters which much not be en/de-coded */
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp * N.B. in addition to :@&=, this allows ';' in an http path
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp * and '?' in an ftp path -- this may be revised
d82d78a97558238d16c52ec5278fe921bb7d7ec3brianp * Also, it makes a '+' character in a search string reserved, as
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * it may be form-encoded. (Although RFC 1738 doesn't allow this -
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * it only permits ; / ? : @ = & as reserved chars.)
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (t == enc_path) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb else if (t == enc_search) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb else if (t == enc_user) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb else if (t == enc_fpath) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb else { /* if (t == enc_parm) */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (t == enc_path) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb else if (t == enc_search) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb for (i = 0, j = 0; i < len; i++, j++) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb/* always handle '/' first */
2d2eda71267231c2526be701fe655db125852c1ffielding * decode it if not already done. do not decode reverse proxied URLs
2d2eda71267231c2526be701fe655db125852c1ffielding * unless specifically forced
2d2eda71267231c2526be701fe655db125852c1ffielding if ((forcedec || (proxyreq && proxyreq != PROXYREQ_REVERSE)) && ch == '%') {
2d2eda71267231c2526be701fe655db125852c1ffielding if (!apr_isxdigit(x[i + 1]) || !apr_isxdigit(x[i + 2])) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (ch != 0 && strchr(reserved, ch)) { /* keep it encoded */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb/* recode it, if necessary */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb y[j] = '\0';
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * Parses network-location.
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * urlp on input the URL; on output the path, after the leading /
3d96ee83babeec32482c9082c9426340cee8c44dwrowe * user NULL if no user/password permitted
2d2eda71267231c2526be701fe655db125852c1ffielding * password holder for password
23ff73a56371e21f16744cb94d06399b877829f1rbb * host holder for host
2d2eda71267231c2526be701fe655db125852c1ffielding * port port number; only set if one is supplied.
62db15de4c1f335a64d45821796ae197cff94ef8rbb * Returns an error string.
62db15de4c1f335a64d45821796ae197cff94ef8rbb ap_proxy_canon_netloc(apr_pool_t *p, char **const urlp, char **userp,
62db15de4c1f335a64d45821796ae197cff94ef8rbb return "Malformed URL";
62db15de4c1f335a64d45821796ae197cff94ef8rbb /* find _last_ '@' since it might occur in user/password part */
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar/* find password */
3d96ee83babeec32482c9082c9426340cee8c44dwrowe password = ap_proxy_canonenc(p, strp + 1, strlen(strp + 1), enc_user, 1, 0);
3d96ee83babeec32482c9082c9426340cee8c44dwrowe return "Bad %-escape in URL (password)";
3d96ee83babeec32482c9082c9426340cee8c44dwrowe user = ap_proxy_canonenc(p, user, strlen(user), enc_user, 1, 0);
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar return "Bad %-escape in URL (username)";
3d96ee83babeec32482c9082c9426340cee8c44dwrowe * Parse the host string to separate host portion from optional port.
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar * Perform range checking on port.
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar rv = apr_parse_addr_port(&addr, &scope_id, &tmp_port, host, p);
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar if (rv != APR_SUCCESS || addr == NULL || scope_id != NULL) {
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar return "Invalid host/port";
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar if (tmp_port != 0) { /* only update caller's port if port was specified */
3d96ee83babeec32482c9082c9426340cee8c44dwrowe ap_str_tolower(addr); /* DNS names are case-insensitive */
91f0d8da77152d24e4bbb31ce199282b3fd6e3b2coar * If the date is a valid RFC 850 date or asctime() date, then it
3d96ee83babeec32482c9082c9426340cee8c44dwrowe * is converted to the RFC 1123 format.
2864362ca8266097928e84f101010bdf814ffa08stoddardPROXY_DECLARE(request_rec *)ap_proxy_make_fake_req(conn_rec *c, request_rec *r)
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * list is a comma-separated list of case-insensitive tokens, with
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * optional whitespace around the tokens.
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * The return returns 1 if the token val is found in the list, or 0
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * otherwise.
3d96ee83babeec32482c9082c9426340cee8c44dwrowePROXY_DECLARE(int) ap_proxy_liststr(const char *list, const char *val)
61fd0cab072a05b855cbef9c585702401ac5ae29rbb const char *p;
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (p != NULL) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb } while (apr_isspace(*p));
2d2eda71267231c2526be701fe655db125852c1ffielding * list is a comma-separated list of case-insensitive tokens, with
2d2eda71267231c2526be701fe655db125852c1ffielding * optional whitespace around the tokens.
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * if val appears on the list of tokens, it is removed from the list,
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * and the new list is returned.
2d2eda71267231c2526be701fe655db125852c1ffieldingPROXY_DECLARE(char *)ap_proxy_removestr(apr_pool_t *pool, const char *list, const char *val)
61fd0cab072a05b855cbef9c585702401ac5ae29rbb const char *p;
d839a9822ee53ce00da24c15f2d9fe054233d342gstein if (p != NULL) {
2d2eda71267231c2526be701fe655db125852c1ffielding } while (apr_isspace(*p));
61fd0cab072a05b855cbef9c585702401ac5ae29rbb /* do nothing */
a6b9ed64fdf548c61de9714e2cfb999ec59d149cgstein new = apr_pstrcat(pool, new, ",", apr_pstrndup(pool, list, i), NULL);
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * Converts 8 hex digits to a time integer
61fd0cab072a05b855cbef9c585702401ac5ae29rbb unsigned int j;
61fd0cab072a05b855cbef9c585702401ac5ae29rbb for (i = 0, j = 0; i < 8; i++) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (j == 0xffffffff) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * Converts a time integer to 8 hex digits
a6b9ed64fdf548c61de9714e2cfb999ec59d149cgstein unsigned int j = t;
61fd0cab072a05b855cbef9c585702401ac5ae29rbb for (i = 7; i >= 0; i--) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbbPROXY_DECLARE(int) ap_proxyerror(request_rec *r, int statuscode, const char *message)
61fd0cab072a05b855cbef9c585702401ac5ae29rbb "The proxy server could not handle the request "
61fd0cab072a05b855cbef9c585702401ac5ae29rbb "Reason: <strong>",
61fd0cab072a05b855cbef9c585702401ac5ae29rbb /* Allow "error-notes" string to be printed by ap_send_error_response() */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb apr_table_setn(r->notes, "verbose-error-to", apr_pstrdup(r->pool, "*"));
61fd0cab072a05b855cbef9c585702401ac5ae29rbb r->status_line = apr_psprintf(r->pool, "%3.3u Proxy Error", statuscode);
61fd0cab072a05b855cbef9c585702401ac5ae29rbbstatic const char *
346029f34d03eb20d84fc35664426d3874b00f9ewrowe char *url, *user = NULL, *password = NULL, *err, *host;
fd8b91502bc200ed4cca3810560a2a570522b3debrianp /* Set url to the first char after "scheme://" */
fd8b91502bc200ed4cca3810560a2a570522b3debrianp if ((url = strchr(r->uri, ':')) == NULL || url[1] != '/' || url[2] != '/') {
fd8b91502bc200ed4cca3810560a2a570522b3debrianp url = apr_pstrdup(r->pool, &url[1]); /* make it point to "//", which is what proxy_canon_netloc expects */
fd8b91502bc200ed4cca3810560a2a570522b3debrianp err = ap_proxy_canon_netloc(r->pool, &url, &user, &password, &host, &port);
fd8b91502bc200ed4cca3810560a2a570522b3debrianp ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "%s", err);
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames/* Return TRUE if addr represents an IP address (or an IP network address) */
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregamesPROXY_DECLARE(int) ap_proxy_is_ipaddr(struct dirconn_entry *This, apr_pool_t *p)
45613d36b9466a48def0498cffa07f48980720f8jerenkrantz * if the address is given with an explicit netmask, use that
fd8b91502bc200ed4cca3810560a2a570522b3debrianp * Due to a deficiency in apr_inet_addr(), it is impossible to parse
fd8b91502bc200ed4cca3810560a2a570522b3debrianp * "partial" addresses (with less than 4 quads) correctly, i.e.
45613d36b9466a48def0498cffa07f48980720f8jerenkrantz * 192.168.123 is parsed as 192.168.0.123, which is not what I want.
45613d36b9466a48def0498cffa07f48980720f8jerenkrantz * I therefore have to parse the IP address manually:
45613d36b9466a48def0498cffa07f48980720f8jerenkrantz * if (proxy_readmask(This->name, &This->addr.s_addr, &This->mask.s_addr) == 0)
fd8b91502bc200ed4cca3810560a2a570522b3debrianp * addr and mask were set by proxy_readmask()
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames * return 1;
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames * Parse IP addr manually, optionally allowing
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames * abbreviated net addresses like 192.168.
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames /* Iterate over up to 4 (dotted) quads. */
4111de96e9f75c58e77c2bdda23be83b8ebf81ccgregames for (quads = 0; quads < 4 && *addr != '\0'; ++quads) {
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (*addr == '/' && quads > 0) { /* netmask starts here. */
2d2eda71267231c2526be701fe655db125852c1ffielding return 0; /* no digit at start of quad */
344f3bc38dfccf6261d5bb8d689794cde113b3d6coar if (tmp == addr) { /* expected a digit, found something else */
5a9667916c79d8c699b069068e5570aa1c331c80gstein /* invalid octet */
fd0edaa8e3d4dd67d0604ccef2e96b071db96643fielding ++addr; /* after the 4th quad, a dot would be illegal */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (addr[0] == '/' && apr_isdigit(addr[1])) { /* net mask follows: */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (tmp == addr) { /* expected a digit, found something else */
61fd0cab072a05b855cbef9c585702401ac5ae29rbb if (bits < 0 || bits > 32) { /* netmask must be between 0 and 32 */
a6b9ed64fdf548c61de9714e2cfb999ec59d149cgstein * Determine (i.e., "guess") netmask by counting the
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * number of trailing .0's; reduce #quads appropriately
61fd0cab072a05b855cbef9c585702401ac5ae29rbb * (so that 192.168.0.0 is equivalent to 192.168.)
fd0edaa8e3d4dd67d0604ccef2e96b071db96643fielding /* "IP Address should be given in dotted-quad form, optionally followed by a netmask (e.g., 192.168.111.0/24)"; */
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb /* every zero-byte counts as 8 zero-bits */
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb if (bits != 32) { /* no warning for fully qualified IP address */
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb "Warning: NetMask not supplied with IP-Addr; guessing: %s/%ld",
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb This->mask.s_addr = htonl(APR_INADDR_NONE << (32 - bits));
9484ae61c7cc5fa8d8d9a836efdbdb1e88d3036dwrowe if (*addr == '\0' && (This->addr.s_addr & ~This->mask.s_addr) != 0) {
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb "Warning: NetMask and IP-Addr disagree in %s/%ld",
fcc25eda7b150e226d3c1cdaea66a943d3fdee4erbb return (*addr == '\0'); /* okay iff we've parsed the whole string */
2fc50921b88defeb7127985dfe4b4130175e069ejwoolley/* Return TRUE if addr represents an IP address (or an IP network address) */
2fc50921b88defeb7127985dfe4b4130175e069ejwoolleystatic int proxy_match_ipaddr(struct dirconn_entry *This, request_rec *r)
c9a95767fbf0f5fb0976a06b97a256033925e433rbb if (4 == sscanf(host, "%d.%d.%d.%d", &ip_addr[0], &ip_addr[1], &ip_addr[2], &ip_addr[3])) {
c9a95767fbf0f5fb0976a06b97a256033925e433rbb /* ap_proxy_is_ipaddr() already confirmed that we have
c9a95767fbf0f5fb0976a06b97a256033925e433rbb * a valid octet in ip_addr[i]
2d2eda71267231c2526be701fe655db125852c1ffielding if (This->addr.s_addr == (addr.s_addr & This->mask.s_addr)) {
#if DEBUGGING
!= APR_SUCCESS) {
#if DEBUGGING
while (reqaddr) {
#if DEBUGGING
#if DEBUGGING
--d_len;
--h_len;
int h2_len;
int h1_len;
while (addr) {
--h2_len;
--h1_len;
return HTTP_FORBIDDEN;
while (conf_addr) {
while (uri_addr) {
char *conf_ip;
char *uri_ip;
return HTTP_FORBIDDEN;
return OK;
return OK;
* ap_rgetline() in protocol.c. Deprecate this function and use ap_rgetline()
apr_bucket *e;
char *response;
int found = 0;
buff[0] = 0;
*eos = 0;
while (!found) {
return rv;
while (!found) {
return APR_ECONNABORTED;
if (APR_BUCKET_IS_EOS(e)) {
(const char **)&response,
&len,
APR_BLOCK_READ))) {
return rv;
if (len > 0) {
return APR_SUCCESS;
if (!initial) {
count++;
return url;
int n, l3 = 0;
if (urlpart) {
* BalancerMember balancer://alias http://example.com/foo
* translate url http://example.com/foo/bar/that to /bash/that
if (urlpart) {
--l2;
NULL);
worker++;
if (part) {
if (part) {
return url;
&proxy_module);
const char *pathp;
const char *domainp;
int ddiff = 0;
int pdiff = 0;
char *ret;
return str;
if (newpath) {
if (newdomain) {
if (newdomain) {
return ret;
const char *url)
return NULL;
return balancer;
balancer++;
return NULL;
const char *url)
if (!lbmethod) {
return NULL;
return APR_SUCCESS;
return APR_SUCCESS;
if (conn->r) {
return APR_SUCCESS;
apr_pool_clear(p);
return APR_SUCCESS;
request_rec *r)
return APR_SUCCESS;
return APR_SUCCESS;
return APR_SUCCESS;
const char *url)
int max_match = 0;
int url_length;
int min_match;
int worker_name_length;
char *url_copy;
return NULL;
char *pathstart;
if (balancer) {
return max_worker;
const char *url)
int rv;
* ProxyPass / http://www.example.com
if (balancer) {
} else if (conf) {
return NULL;
PROXY_DECLARE(apr_status_t) ap_proxy_share_worker(proxy_worker *worker, proxy_worker_shared *shm, int i)
return APR_EINVAL;
return APR_SUCCESS;
PROXY_DECLARE(apr_status_t) ap_proxy_initialize_worker(proxy_worker *worker, server_rec *s, apr_pool_t *p)
int mpm_threads;
return APR_EGENERAL;
return rv;
void *conn;
return rv;
server_rec *s)
return OK;
return DECLINED;
return OK;
request_rec *r,
int access_status;
if (*worker) {
*url);
*url);
*url);
return access_status;
request_rec *r,
if (balancer) {
return access_status;
const char *proxy_function,
const char *backend_name,
request_rec *r)
int connected = 0;
int loglevel;
server_rec *s)
return HTTP_SERVICE_UNAVAILABLE;
return HTTP_SERVICE_UNAVAILABLE;
return OK;
server_rec *s)
return OK;
PROXY_DECLARE(int)
char **url,
const char *proxyname,
char *server_portstr,
int server_portstr_size)
int server_port;
NULL));
if (!proxyname) {
if (proxyname) {
const char *proxy_auth;
return HTTP_INTERNAL_SERVER_ERROR;
return OK;
server_rec *s)
int status;
int complete = 0;
int len = 0;
if (!complete) {
buffer);
code_str);
return(status);
server_rec *s)
int connected = 0;
int loglevel;
conn_rec *c,
server_rec *s)
int rc;
return OK;
0, NULL,
return HTTP_INTERNAL_SERVER_ERROR;
return HTTP_INTERNAL_SERVER_ERROR;
return rc;
return OK;
int ap_proxy_lb_workers(void)
if (!lb_workers_limit)
return lb_workers_limit;
apr_bucket *e;
if (r->main)
c->bucket_alloc);
apr_bucket *e;
const char *data;
e = APR_BUCKET_NEXT(e)) {
if (!APR_BUCKET_IS_METADATA(e)) {
else if (APR_BUCKET_IS_FLUSH(e)) {
else if (APR_BUCKET_IS_EOS(e)) {
return rv;
PROXY_DECLARE(unsigned int)
unsigned int hash;
return hash;
unsigned int hash;
return hash;