/* 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.

 */

/* Load balancer module for Apache proxy */

#include "mod_proxy.h"

#include "scoreboard.h"

#include "ap_mpm.h"

#include "apr_version.h"

#include "ap_hooks.h"

#include "apr_date.h"

#include "util_md5.h"

#include "mod_watchdog.h"

static const char *balancer_mutex_type = "proxy-balancer-shm";

ap_slotmem_provider_t *storage = NULL;

module AP_MODULE_DECLARE_DATA proxy_balancer_module;

static APR_OPTIONAL_FN_TYPE(set_worker_hc_param) *set_worker_hc_param_f = NULL;

static int (*ap_proxy_retry_worker_fn)(const char *proxy_function,

        proxy_worker *worker, server_rec *s) = NULL;

static APR_OPTIONAL_FN_TYPE(hc_show_exprs) *hc_show_exprs_f = NULL;

static APR_OPTIONAL_FN_TYPE(hc_select_exprs) *hc_select_exprs_f = NULL;

static APR_OPTIONAL_FN_TYPE(hc_valid_expr) *hc_valid_expr_f = NULL;

/*

 * Register our mutex type before the config is read so we

 * can adjust the mutex settings using the Mutex directive.

 */

static int balancer_pre_config(apr_pool_t *pconf, apr_pool_t *plog,

                               apr_pool_t *ptemp)

{

    apr_status_t rv;

    rv = ap_mutex_register(pconf, balancer_mutex_type, NULL,

                               APR_LOCK_DEFAULT, 0);

    if (rv != APR_SUCCESS) {

        return rv;

    }

    set_worker_hc_param_f = APR_RETRIEVE_OPTIONAL_FN(set_worker_hc_param);

    hc_show_exprs_f = APR_RETRIEVE_OPTIONAL_FN(hc_show_exprs);

    hc_select_exprs_f = APR_RETRIEVE_OPTIONAL_FN(hc_select_exprs);

    hc_valid_expr_f = APR_RETRIEVE_OPTIONAL_FN(hc_valid_expr);

    return OK;

}

#if 0

extern void proxy_update_members(proxy_balancer **balancer, request_rec *r,

                                 proxy_server_conf *conf);

#endif

static int proxy_balancer_canon(request_rec *r, char *url)

{

    char *host, *path;

    char *search = NULL;

    const char *err;

    apr_port_t port = 0;

    /* TODO: offset of BALANCER_PREFIX ?? */

    if (strncasecmp(url, "balancer:", 9) == 0) {

        url += 9;

    }

    else {

        return DECLINED;

    }

    ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, "canonicalising URL %s", url);

    /* do syntatic check.

     * We break the URL into host, port, path, search

     */

    err = ap_proxy_canon_netloc(r->pool, &url, NULL, NULL, &host, &port);

    if (err) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01157)

                      "error parsing URL %s: %s",

                      url, err);

        return HTTP_BAD_REQUEST;

    }

    /*

     * now parse path/search args, according to rfc1738:

     * process the path. With proxy-noncanon set (by

     * mod_proxy) we use the raw, unparsed uri

     */

    if (apr_table_get(r->notes, "proxy-nocanon")) {

        path = url;   /* this is the raw path */

    }

    else {

        path = ap_proxy_canonenc(r->pool, url, strlen(url), enc_path, 0,

                                 r->proxyreq);

        search = r->args;

    }

    if (path == NULL)

        return HTTP_BAD_REQUEST;

    r->filename = apr_pstrcat(r->pool, "proxy:" BALANCER_PREFIX, host,

            "/", path, (search) ? "?" : "", (search) ? search : "", NULL);

    r->path_info = apr_pstrcat(r->pool, "/", path, NULL);

    return OK;

}

static void init_balancer_members(apr_pool_t *p, server_rec *s,

                                 proxy_balancer *balancer)

{

    int i;

    proxy_worker **workers;

    workers = (proxy_worker **)balancer->workers->elts;

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

        int worker_is_initialized;

        proxy_worker *worker = *workers;

        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01158)

                     "Looking at %s -> %s initialized?", balancer->s->name,

                     ap_proxy_worker_name(p, worker));

        worker_is_initialized = PROXY_WORKER_IS_INITIALIZED(worker);

        if (!worker_is_initialized) {

            ap_proxy_initialize_worker(worker, s, p);

        }

        ++workers;

    }

    /* Set default number of attempts to the number of

     * workers.

     */

    if (!balancer->s->max_attempts_set && balancer->workers->nelts > 1) {

        balancer->s->max_attempts = balancer->workers->nelts - 1;

        balancer->s->max_attempts_set = 1;

    }

}

/* Retrieve the parameter with the given name

 * Something like 'JSESSIONID=12345...N'

 */

static char *get_path_param(apr_pool_t *pool, char *url,

                            const char *name, int scolon_sep)

{

    char *path = NULL;

    char *pathdelims = "?&";

    if (scolon_sep) {

        pathdelims = ";?&";

    }

    for (path = strstr(url, name); path; path = strstr(path + 1, name)) {

        path += strlen(name);

        if (*path == '=') {

            /*

             * Session path was found, get its value

             */

            ++path;

            if (*path) {

                char *q;

                path = apr_strtok(apr_pstrdup(pool, path), pathdelims, &q);

                return path;

            }

        }

    }

    return NULL;

}

static char *get_cookie_param(request_rec *r, const char *name)

{

    const char *cookies;

    const char *start_cookie;

    if ((cookies = apr_table_get(r->headers_in, "Cookie"))) {

        for (start_cookie = ap_strstr_c(cookies, name); start_cookie;

             start_cookie = ap_strstr_c(start_cookie + 1, name)) {

            if (start_cookie == cookies ||

                start_cookie[-1] == ';' ||

                start_cookie[-1] == ',' ||

                isspace(start_cookie[-1])) {

                start_cookie += strlen(name);

                while(*start_cookie && isspace(*start_cookie))

                    ++start_cookie;

                if (*start_cookie++ == '=' && *start_cookie) {

                    /*

                     * Session cookie was found, get its value

                     */

                    char *end_cookie, *cookie;

                    cookie = apr_pstrdup(r->pool, start_cookie);

                    if ((end_cookie = strchr(cookie, ';')) != NULL)

                        *end_cookie = '\0';

                    if((end_cookie = strchr(cookie, ',')) != NULL)

                        *end_cookie = '\0';

                    return cookie;

                }

            }

        }

    }

    return NULL;

}

/* Find the worker that has the 'route' defined

 */

static proxy_worker *find_route_worker(proxy_balancer *balancer,

                                       const char *route, request_rec *r,

                                       int recursion)

{

    int i;

    int checking_standby;

    int checked_standby;

    proxy_worker **workers;

    checking_standby = checked_standby = 0;

    while (!checked_standby) {

        workers = (proxy_worker **)balancer->workers->elts;

        for (i = 0; i < balancer->workers->nelts; i++, workers++) {

            proxy_worker *worker = *workers;

            if ( (checking_standby ? !PROXY_WORKER_IS_STANDBY(worker) : PROXY_WORKER_IS_STANDBY(worker)) )

                continue;

            if (*(worker->s->route) && strcmp(worker->s->route, route) == 0) {

                if (PROXY_WORKER_IS_USABLE(worker)) {

                    return worker;

                } else {

                    /*

                     * If the worker is in error state run

                     * retry on that worker. It will be marked as

                     * operational if the retry timeout is elapsed.

                     * The worker might still be unusable, but we try

                     * anyway.

                     */

                    ap_proxy_retry_worker_fn("BALANCER", worker, r->server);

                    if (PROXY_WORKER_IS_USABLE(worker)) {

                            return worker;

                    } else {

                        /*

                         * We have a worker that is unusable.

                         * It can be in error or disabled, but in case

                         * it has a redirection set use that redirection worker.

                         * This enables to safely remove the member from the

                         * balancer. Of course you will need some kind of

                         * session replication between those two remote.

                         * Also check that we haven't gone thru all the

                         * balancer members by means of redirects.

                         * This should avoid redirect cycles.

                         */

                        if ((*worker->s->redirect)

                            && (recursion < balancer->workers->nelts)) {

                            proxy_worker *rworker = NULL;

                            rworker = find_route_worker(balancer, worker->s->redirect,

                                                        r, recursion + 1);

                            /* Check if the redirect worker is usable */

                            if (rworker && !PROXY_WORKER_IS_USABLE(rworker)) {

                                /*

                                 * If the worker is in error state run

                                 * retry on that worker. It will be marked as

                                 * operational if the retry timeout is elapsed.

                                 * The worker might still be unusable, but we try

                                 * anyway.

                                 */

                                ap_proxy_retry_worker_fn("BALANCER", rworker, r->server);

                            }

                            if (rworker && PROXY_WORKER_IS_USABLE(rworker))

                                return rworker;

                        }

                    }

                }

            }

        }

        checked_standby = checking_standby++;

    }

    return NULL;

}

static proxy_worker *find_session_route(proxy_balancer *balancer,

                                        request_rec *r,

                                        char **route,

                                        const char **sticky_used,

                                        char **url)

{

    proxy_worker *worker = NULL;

    if (!*balancer->s->sticky)

        return NULL;

    /* Try to find the sticky route inside url */

    *route = get_path_param(r->pool, *url, balancer->s->sticky_path, balancer->s->scolonsep);

    if (*route) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01159)

                     "Found value %s for stickysession %s",

                     *route, balancer->s->sticky_path);

        *sticky_used =  balancer->s->sticky_path;

    }

    else {

        *route = get_cookie_param(r, balancer->s->sticky);

        if (*route) {

            *sticky_used =  balancer->s->sticky;

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01160)

                         "Found value %s for stickysession %s",

                         *route, balancer->s->sticky);

        }

    }

    /*

     * If we found a value for stickysession, find the first '.' (or whatever

     * sticky_separator is set to) within. Everything after '.' (if present)

     * is our route. 

     */

    if ((*route) && (balancer->s->sticky_separator != 0) && ((*route = strchr(*route, balancer->s->sticky_separator)) != NULL ))

        (*route)++;

    if ((*route) && (**route)) {

        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01161) "Found route %s", *route);

        /* We have a route in path or in cookie

         * Find the worker that has this route defined.

         */

        worker = find_route_worker(balancer, *route, r, 1);

        if (worker && strcmp(*route, worker->s->route)) {

            /*

             * Notice that the route of the worker chosen is different from

             * the route supplied by the client.

             */

            apr_table_setn(r->subprocess_env, "BALANCER_ROUTE_CHANGED", "1");

            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01162)

                          "Route changed from %s to %s",

                          *route, worker->s->route);

        }

        return worker;

    }

    else

        return NULL;

}

static proxy_worker *find_best_worker(proxy_balancer *balancer,

                                      request_rec *r)

{

    proxy_worker *candidate = NULL;

    apr_status_t rv;

    if ((rv = PROXY_THREAD_LOCK(balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01163)

                      "%s: Lock failed for find_best_worker()",

                      balancer->s->name);

        return NULL;

    }

    candidate = (*balancer->lbmethod->finder)(balancer, r);

    if (candidate)

        candidate->s->elected++;

    if ((rv = PROXY_THREAD_UNLOCK(balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01164)

                      "%s: Unlock failed for find_best_worker()",

                      balancer->s->name);

    }

    if (candidate == NULL) {

        /* All the workers are in error state or disabled.

         * If the balancer has a timeout sleep for a while

         * and try again to find the worker. The chances are

         * that some other thread will release a connection.

         * By default the timeout is not set, and the server

         * returns SERVER_BUSY.

         */

        if (balancer->s->timeout) {

            /* XXX: This can perhaps be build using some

             * smarter mechanism, like tread_cond.

             * But since the statuses can came from

             * different childs, use the provided algo.

             */

            apr_interval_time_t timeout = balancer->s->timeout;

            apr_interval_time_t step, tval = 0;

            /* Set the timeout to 0 so that we don't

             * end in infinite loop

             */

            balancer->s->timeout = 0;

            step = timeout / 100;

            while (tval < timeout) {

                apr_sleep(step);

                /* Try again */

                if ((candidate = find_best_worker(balancer, r)))

                    break;

                tval += step;

            }

            /* restore the timeout */

            balancer->s->timeout = timeout;

        }

    }

    return candidate;

}

static int rewrite_url(request_rec *r, proxy_worker *worker,

                        char **url)

{

    const char *scheme = strstr(*url, "://");

    const char *path = NULL;

    if (scheme)

        path = ap_strchr_c(scheme + 3, '/');

    /* we break the URL into host, port, uri */

    if (!worker) {

        return ap_proxyerror(r, HTTP_BAD_REQUEST, apr_pstrcat(r->pool,

                             "missing worker. URI cannot be parsed: ", *url,

                             NULL));

    }

    *url = apr_pstrcat(r->pool, worker->s->name, path, NULL);

    return OK;

}

static void force_recovery(proxy_balancer *balancer, server_rec *s)

{

    int i;

    int ok = 0;

    proxy_worker **worker;

    worker = (proxy_worker **)balancer->workers->elts;

    for (i = 0; i < balancer->workers->nelts; i++, worker++) {

        if (!((*worker)->s->status & PROXY_WORKER_IN_ERROR)) {

            ok = 1;

            break;

        }

        else {

            /* Try if we can recover */

            ap_proxy_retry_worker_fn("BALANCER", *worker, s);

            if (!((*worker)->s->status & PROXY_WORKER_IN_ERROR)) {

                ok = 1;

                break;

            }

        }

    }

    if (!ok && balancer->s->forcerecovery) {

        /* If all workers are in error state force the recovery.

         */

        worker = (proxy_worker **)balancer->workers->elts;

        for (i = 0; i < balancer->workers->nelts; i++, worker++) {

            ++(*worker)->s->retries;

            (*worker)->s->status &= ~PROXY_WORKER_IN_ERROR;

            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(01165)

                         "%s: Forcing recovery for worker (%s)",

                         balancer->s->name, (*worker)->s->hostname_ex);

        }

    }

}

static apr_status_t decrement_busy_count(void *worker_)

{

    proxy_worker *worker = worker_;

    if (worker->s->busy) {

        worker->s->busy--;

    }

    return APR_SUCCESS;

}

static int proxy_balancer_pre_request(proxy_worker **worker,

                                      proxy_balancer **balancer,

                                      request_rec *r,

                                      proxy_server_conf *conf, char **url)

{

    int access_status;

    proxy_worker *runtime;

    char *route = NULL;

    const char *sticky = NULL;

    apr_status_t rv;

    *worker = NULL;

    /* Step 1: check if the url is for us

     * The url we can handle starts with 'balancer://'

     * If balancer is already provided skip the search

     * for balancer, because this is failover attempt.

     */

    if (!*balancer &&

        !(*balancer = ap_proxy_get_balancer(r->pool, conf, *url, 1)))

        return DECLINED;

    /* Step 2: Lock the LoadBalancer

     * XXX: perhaps we need the process lock here

     */

    if ((rv = PROXY_THREAD_LOCK(*balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01166)

                      "%s: Lock failed for pre_request", (*balancer)->s->name);

        return DECLINED;

    }

    /* Step 3: force recovery */

    force_recovery(*balancer, r->server);

    /* Step 3.5: Update member list for the balancer */

    /* TODO: Implement as provider! */

    ap_proxy_sync_balancer(*balancer, r->server, conf);

    /* Step 4: find the session route */

    runtime = find_session_route(*balancer, r, &route, &sticky, url);

    if (runtime) {

        if ((*balancer)->lbmethod && (*balancer)->lbmethod->updatelbstatus) {

            /* Call the LB implementation */

            (*balancer)->lbmethod->updatelbstatus(*balancer, runtime, r->server);

        }

        else { /* Use the default one */

            int i, total_factor = 0;

            proxy_worker **workers;

            /* We have a sticky load balancer

             * Update the workers status

             * so that even session routes get

             * into account.

             */

            workers = (proxy_worker **)(*balancer)->workers->elts;

            for (i = 0; i < (*balancer)->workers->nelts; i++) {

                /* Take into calculation only the workers that are

                 * not in error state or not disabled.

                 */

                if (PROXY_WORKER_IS_USABLE(*workers)) {

                    (*workers)->s->lbstatus += (*workers)->s->lbfactor;

                    total_factor += (*workers)->s->lbfactor;

                }

                workers++;

            }

            runtime->s->lbstatus -= total_factor;

        }

        runtime->s->elected++;

        *worker = runtime;

    }

    else if (route && (*balancer)->s->sticky_force) {

        int i, member_of = 0;

        proxy_worker **workers;

        /*

         * We have a route provided that doesn't match the

         * balancer name. See if the provider route is the

         * member of the same balancer in which case return 503

         */

        workers = (proxy_worker **)(*balancer)->workers->elts;

        for (i = 0; i < (*balancer)->workers->nelts; i++) {

            if (*((*workers)->s->route) && strcmp((*workers)->s->route, route) == 0) {

                member_of = 1;

                break;

            }

            workers++;

        }

        if (member_of) {

            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01167)

                          "%s: All workers are in error state for route (%s)",

                          (*balancer)->s->name, route);

            if ((rv = PROXY_THREAD_UNLOCK(*balancer)) != APR_SUCCESS) {

                ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01168)

                              "%s: Unlock failed for pre_request",

                              (*balancer)->s->name);

            }

            return HTTP_SERVICE_UNAVAILABLE;

        }

    }

    if ((rv = PROXY_THREAD_UNLOCK(*balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01169)

                      "%s: Unlock failed for pre_request",

                      (*balancer)->s->name);

    }

    if (!*worker) {

        runtime = find_best_worker(*balancer, r);

        if (!runtime) {

            if ((*balancer)->workers->nelts) {

                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01170)

                              "%s: All workers are in error state",

                              (*balancer)->s->name);

            } else {

                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01171)

                              "%s: No workers in balancer",

                              (*balancer)->s->name);

            }

            return HTTP_SERVICE_UNAVAILABLE;

        }

        if (*(*balancer)->s->sticky && runtime) {

            /*

             * This balancer has sticky sessions and the client either has not

             * supplied any routing information or all workers for this route

             * including possible redirect and hotstandby workers are in error

             * state, but we have found another working worker for this

             * balancer where we can send the request. Thus notice that we have

             * changed the route to the backend.

             */

            apr_table_setn(r->subprocess_env, "BALANCER_ROUTE_CHANGED", "1");

        }

        *worker = runtime;

    }

    (*worker)->s->busy++;

    apr_pool_cleanup_register(r->pool, *worker, decrement_busy_count,

                              apr_pool_cleanup_null);

    /* Add balancer/worker info to env. */

    apr_table_setn(r->subprocess_env,

                   "BALANCER_NAME", (*balancer)->s->name);

    apr_table_setn(r->subprocess_env,

                   "BALANCER_WORKER_NAME", (*worker)->s->name);

    apr_table_setn(r->subprocess_env,

                   "BALANCER_WORKER_ROUTE", (*worker)->s->route);

    /* Rewrite the url from 'balancer://url'

     * to the 'worker_scheme://worker_hostname[:worker_port]/url'

     * This replaces the balancers fictional name with the

     * real hostname of the elected worker.

     */

    access_status = rewrite_url(r, *worker, url);

    /* Add the session route to request notes if present */

    if (route) {

        apr_table_setn(r->notes, "session-sticky", sticky);

        apr_table_setn(r->notes, "session-route", route);

        /* Add session info to env. */

        apr_table_setn(r->subprocess_env,

                       "BALANCER_SESSION_STICKY", sticky);

        apr_table_setn(r->subprocess_env,

                       "BALANCER_SESSION_ROUTE", route);

    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01172)

                  "%s: worker (%s) rewritten to %s",

                  (*balancer)->s->name, (*worker)->s->name, *url);

    return access_status;

}

static int proxy_balancer_post_request(proxy_worker *worker,

                                       proxy_balancer *balancer,

                                       request_rec *r,

                                       proxy_server_conf *conf)

{

    apr_status_t rv;

    if ((rv = PROXY_THREAD_LOCK(balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01173)

                      "%s: Lock failed for post_request",

                      balancer->s->name);

        return HTTP_INTERNAL_SERVER_ERROR;

    }

    if (!apr_is_empty_array(balancer->errstatuses)

        && !(worker->s->status & PROXY_WORKER_IGNORE_ERRORS)) {

        int i;

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

            int val = ((int *)balancer->errstatuses->elts)[i];

            if (r->status == val) {

                ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01174)

                              "%s: Forcing worker (%s) into error state "

                              "due to status code %d matching 'failonstatus' "

                              "balancer parameter",

                              balancer->s->name, ap_proxy_worker_name(r->pool, worker),

                              val);

                worker->s->status |= PROXY_WORKER_IN_ERROR;

                worker->s->error_time = apr_time_now();

                break;

            }

        }

    }

    if (balancer->failontimeout

        && !(worker->s->status & PROXY_WORKER_IGNORE_ERRORS)

        && (apr_table_get(r->notes, "proxy_timedout")) != NULL) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02460)

                      "%s: Forcing worker (%s) into error state "

                      "due to timeout and 'failontimeout' parameter being set",

                       balancer->s->name, ap_proxy_worker_name(r->pool, worker));

        worker->s->status |= PROXY_WORKER_IN_ERROR;

        worker->s->error_time = apr_time_now();

    }

    if ((rv = PROXY_THREAD_UNLOCK(balancer)) != APR_SUCCESS) {

        ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01175)

                      "%s: Unlock failed for post_request", balancer->s->name);

    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01176)

                  "proxy_balancer_post_request for (%s)", balancer->s->name);

    return OK;

}

static void recalc_factors(proxy_balancer *balancer)

{

    int i;

    proxy_worker **workers;

    /* Recalculate lbfactors */

    workers = (proxy_worker **)balancer->workers->elts;

    /* Special case if there is only one worker its

     * load factor will always be 100

     */

    if (balancer->workers->nelts == 1) {

        (*workers)->s->lbstatus = (*workers)->s->lbfactor = 100;

        return;

    }

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

        /* Update the status entries */

        workers[i]->s->lbstatus = workers[i]->s->lbfactor;

    }

}

static apr_status_t lock_remove(void *data)

{

    int i;

    proxy_balancer *balancer;

    server_rec *s = data;

    void *sconf = s->module_config;

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

    balancer = (proxy_balancer *)conf->balancers->elts;

    for (i = 0; i < conf->balancers->nelts; i++, balancer++) {

        if (balancer->gmutex) {

            apr_global_mutex_destroy(balancer->gmutex);

            balancer->gmutex = NULL;

        }

    }

    return(0);

}

/*

 * Compute an ID for a vhost based on what makes it selected by requests.

 * The second and more Host(s)/IP(s):port(s), and the ServerAlias(es) are

 * optional (see make_servers_ids() below).

 */

 static const char *make_server_id(server_rec *s, apr_pool_t *p, int full)

{

    apr_md5_ctx_t md5_ctx;

    unsigned char md5[APR_MD5_DIGESTSIZE];

    char id[2 * APR_MD5_DIGESTSIZE + 1];

    char host_ip[64]; /* for any IPv[46] string */

    server_addr_rec *sar;

    int i;

    apr_md5_init(&md5_ctx);

    for (sar = s->addrs; sar; sar = sar->next) {

        host_ip[0] = '\0';

        apr_sockaddr_ip_getbuf(host_ip, sizeof host_ip, sar->host_addr);

        apr_md5_update(&md5_ctx, (void *)sar->virthost, strlen(sar->virthost));

        apr_md5_update(&md5_ctx, (void *)host_ip, strlen(host_ip));

        apr_md5_update(&md5_ctx, (void *)&sar->host_port,

                       sizeof(sar->host_port));

        if (!full) {

            break;

        }

    }

    if (s->server_hostname) {

        apr_md5_update(&md5_ctx, (void *)s->server_hostname,

                       strlen(s->server_hostname));

    }

    if (full) {

        if (s->names) {

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

                const char *name = APR_ARRAY_IDX(s->names, i, char *);

                apr_md5_update(&md5_ctx, (void *)name, strlen(name));

            }

        }

        if (s->wild_names) {

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

                const char *name = APR_ARRAY_IDX(s->wild_names, i, char *);

                apr_md5_update(&md5_ctx, (void *)name, strlen(name));

            }

        }

    }

    apr_md5_final(md5, &md5_ctx);

    ap_bin2hex(md5, APR_MD5_DIGESTSIZE, id);

    return apr_pstrmemdup(p, id, sizeof(id) - 1);

}

/*

 * First try to compute an unique ID for each vhost with minimal criteria,

 * that is the first Host/IP:port and ServerName. For most cases this should

 * be enough and avoids changing the ID unnecessarily accross restart (or

 * stop/start w.r.t. persisted files) for things that this module does not

 * care about.

 *

 * But if it's not enough (collisions) do a second pass for the full monty,

 * that is additionally the other Host(s)/IP(s):port(s) and ServerAlias(es).

 *

 * Finally, for pathological configs where this is still not enough, let's

 * append a counter to duplicates, because we really want that ID to be unique

 * even if the vhost will never be selected to handle requests at run time, at

 * load time a duplicate may steal the original slotmems (depending on its

 * balancers' configurations), see how mod_slotmem_shm reuses slots/files based

 * solely on this ID and resets them if the sizes don't match.

 */

static apr_array_header_t *make_servers_ids(server_rec *main_s, apr_pool_t *p)

{

    server_rec *s = main_s;

    apr_array_header_t *ids = apr_array_make(p, 10, sizeof(const char *));

    apr_hash_t *dups = apr_hash_make(p);

    int idx, *dup, full_monty = 0;

    const char *id;

    for (idx = 0, s = main_s; s; s = s->next, ++idx) {

        id = make_server_id(s, p, 0);

        dup = apr_hash_get(dups, id, APR_HASH_KEY_STRING);

        apr_hash_set(dups, id, APR_HASH_KEY_STRING,

                     apr_pmemdup(p, &idx, sizeof(int)));

        if (dup) {

            full_monty = 1;

            APR_ARRAY_IDX(ids, *dup, const char *) = NULL;

            APR_ARRAY_PUSH(ids, const char *) = NULL;

        }

        else {

            APR_ARRAY_PUSH(ids, const char *) = id;

        }

    }

    if (full_monty) {

        apr_hash_clear(dups);

        for (idx = 0, s = main_s; s; s = s->next, ++idx) {

            id = APR_ARRAY_IDX(ids, idx, const char *);

            if (id) {

                /* Preserve non-duplicates */

                continue;

            }

            id = make_server_id(s, p, 1);

            if (apr_hash_get(dups, id, APR_HASH_KEY_STRING)) {

                id = apr_psprintf(p, "%s_%x", id, idx);

            }

            else {

                apr_hash_set(dups, id, APR_HASH_KEY_STRING, (void *)-1);

            }

            APR_ARRAY_IDX(ids, idx, const char *) = id;

        }

    }

    return ids;

}

/* post_config hook: */

static int balancer_post_config(apr_pool_t *pconf, apr_pool_t *plog,

                         apr_pool_t *ptemp, server_rec *s)

{

    apr_status_t rv;

    proxy_server_conf *conf;

    ap_slotmem_instance_t *new = NULL;

    apr_time_t tstamp;

    apr_array_header_t *ids;

    int idx;

    /* balancer_post_config() will be called twice during startup.  So, don't

     * set up the static data the 1st time through. */

    if (ap_state_query(AP_SQ_MAIN_STATE) == AP_SQ_MS_CREATE_PRE_CONFIG) {

        return OK;

    }

    ap_proxy_retry_worker_fn =

            APR_RETRIEVE_OPTIONAL_FN(ap_proxy_retry_worker);

    if (!ap_proxy_retry_worker_fn) {

        ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s, APLOGNO(02230)

                     "mod_proxy must be loaded for mod_proxy_balancer");

        return !OK;

    }

    /*

     * Get slotmem setups

     */

    storage = ap_lookup_provider(AP_SLOTMEM_PROVIDER_GROUP, "shm",

                                 AP_SLOTMEM_PROVIDER_VERSION);

    if (!storage) {

        ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s, APLOGNO(01177)

                     "Failed to lookup provider 'shm' for '%s': is "

                     "mod_slotmem_shm loaded??",

                     AP_SLOTMEM_PROVIDER_GROUP);

        return !OK;