apr_status_t bind_to_addr(apr_socket_t *newsock, apr_sockaddr_t *laddr,

        const char *proxy_function, proxy_bind_addr *bind, server_rec *s)

{

    int i;

    const int idx = bind->idx;

    const int range = bind->range;

    const int start = bind->port;

    for(i = 0; i < range; ++i) { /* loop until we can bind correctly*/

        int port = start + ((idx + i) % range);

        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "proxy: %s: trying to bind to %s:%u",

                proxy_function, laddr,port, NULL);

        laddr->port = port;

        laddr->sa.sin.sin_port = htons(port);

        if (apr_socket_bind(newsock, laddr) == APR_SUCCESS) {

            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "proxy: %s: bound to %s:%u",

                    proxy_function, laddr, laddr->port, NULL);

            bind->idx = (port - start + 1) % range;

            return APR_SUCCESS;

        }

    }

    return APR_EINVAL;

}

        proxy_bind_addr* bind = (worker->bind ? worker->bind : conf->bind);

        if (bind) {

            rv = APR_EINVAL;

            apr_sockaddr_t *addr;

            for(addr = bind->addr; addr; addr = addr->next) {

                if (addr->family != backend_addr->family) continue;

                rv = bind_to_addr(newsock, addr, proxy_function, bind, s);

                if (rv == APR_SUCCESS) break;

            }

            if (rv != APR_SUCCESS) {

                ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, "proxy: %s: can not bind to %s:%u+%u",

                        proxy_function,bind->addr, bind->port, bind->range - 1, NULL);

                return DECLINED;

            }

        } else {

            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "proxy: Not using bind ",proxy_function);

        }

/* Value from /usr/sys/port_kernel.h is it exposed in any portable header? */

#define PORT_MAX_PORTS 0x10000

/* a sane value for RANGE of bind */

#define MIN_RANGE_HINT 8

static int parse_bind_address(char* val,

                                apr_sockaddr_t **bind_addr,

                                apr_port_t *bind_port,

                                apr_port_t *range,

                                apr_pool_t *p);

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

        proxy_bind_addr* bind =

            (proxy_bind_addr*) apr_pcalloc(p, sizeof(proxy_bind_addr));

        switch (parse_bind_address((char*)val, &(bind->addr),  &(bind->port), &(bind->range), p)) {

            case -1:

                return "ProxySet bind:  Invalid address -"

                    " format is <addr>[:<port>+<range>]";

            case -2:

                return "ProxySet bind: Hostname did not resolve.";

        }

        bind->idx = 0;

        worker->bind = bind;

    }

static int parse_bind_address(char* val,

                                apr_sockaddr_t **bind_addr,

                                apr_port_t *port,

                                apr_port_t *r, apr_pool_t *p) {

    char* range, *host, *scope_id;

    range = ap_strrchr((char*)val,'+');

    if (range) {

        *range++ = 0;

        *r = atoi(range) + 1;

        if (*r < MIN_RANGE_HINT)

            ap_log_error(APLOG_MARK, APLOG_WARNING, 0, NULL,

                    "range %u is too low, consider increasing the bind range.", (*r) - 1, NULL);

    } else *r = 1; /* No range => "+0" -- internally 1 */

    /* We dont accept a single port with out a range as it would be same

    * as a single threaded single process http-client

    *

    * We do not allow ip:0+0 or ip:0 as it can be specified more clearly

    * as just ip.

    *

    * we dont accept a range with out a port either.

    */

    if((apr_parse_addr_port(&host, &scope_id, port, val, p) != APR_SUCCESS)

          || scope_id               /* we dont know how to use scope_id */

          || (!*port && range)       /* only a combo [port+range] is valid */

          || (*port && (!range || *r <= 0)) /* Let admin specify r=0 if he wants to */

          || ((*port + *r) > PORT_MAX_PORTS)

    )

        return -1;

    /* Preparse the address */

    if((apr_sockaddr_info_get(bind_addr, host, APR_UNSPEC, *port, 0, p)

                != APR_SUCCESS) || !*bind_addr)

        return -2;

}

    ps->bind = NULL;

    ps->bind = (overrides->bind ? overrides->bind : base->bind);

static const char*

    set_proxy_bindaddr(cmd_parms *parms, void *dummy, const char *addr)

{

    proxy_server_conf *psf =

        ap_get_module_config(parms->server->module_config, &proxy_module);

    proxy_bind_addr* bind =

        (proxy_bind_addr*) apr_pcalloc(parms->pool, sizeof(proxy_bind_addr));

    switch (parse_bind_address((char*)addr, &(bind->addr),  &(bind->port), &(bind->range), parms->pool)) {

        case -1:

            return "ProxyBindAddress:  Invalid address -"

                " format is <addr>[:<port>+<range>]";

        case -2:

            return "ProxyBindAddress: Hostname did not resolve.";

    }

    bind->idx = 0;

    psf->bind = bind;

    return NULL;

}

    AP_INIT_TAKE1("ProxyBindAddress", set_proxy_bindaddr, NULL, RSRC_CONF,

            "Set the source address for a proxied connection."),

/*bind to local ports*/

    apr_sockaddr_t *addr;

    apr_port_t port;

    apr_port_t range;             /* restrict the source ports used by mod_proxy */

    int idx;

} proxy_bind_addr;

typedef struct {

    /*bind to local ports*/

    proxy_bind_addr* bind;

    /*bind to local ports*/

    proxy_bind_addr* bind;