//
//  ========================================================================
//  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.servlets;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.MalformedURLException;
import java.net.Socket;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.UnavailableException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.client.HttpClient;
import org.eclipse.jetty.client.HttpExchange;
import org.eclipse.jetty.continuation.Continuation;
import org.eclipse.jetty.continuation.ContinuationSupport;
import org.eclipse.jetty.http.HttpHeaderValues;
import org.eclipse.jetty.http.HttpHeaders;
import org.eclipse.jetty.http.HttpSchemes;
import org.eclipse.jetty.http.HttpURI;
import org.eclipse.jetty.http.PathMap;
import org.eclipse.jetty.io.Buffer;
import org.eclipse.jetty.io.EofException;
import org.eclipse.jetty.util.HostMap;
import org.eclipse.jetty.util.IO;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.thread.QueuedThreadPool;

/**
 * Asynchronous Proxy Servlet.
 *
 * Forward requests to another server either as a standard web proxy (as defined by RFC2616) or as a transparent proxy.
 * <p>
 * This servlet needs the jetty-util and jetty-client classes to be available to the web application.
 * <p>
 * To facilitate JMX monitoring, the "HttpClient" and "ThreadPool" are set as context attributes prefixed with the servlet name.
 * <p>
 * The following init parameters may be used to configure the servlet:
 * <ul>
 * <li>name - Name of Proxy servlet (default: "ProxyServlet"
 * <li>maxThreads - maximum threads
 * <li>maxConnections - maximum connections per destination
 * <li>timeout - the period in ms the client will wait for a response from the proxied server
 * <li>idleTimeout - the period in ms a connection to proxied server can be idle for before it is closed
 * <li>requestHeaderSize - the size of the request header buffer (d. 6,144)
 * <li>requestBufferSize - the size of the request buffer (d. 12,288)
 * <li>responseHeaderSize - the size of the response header buffer (d. 6,144)
 * <li>responseBufferSize - the size of the response buffer (d. 32,768)
 * <li>HostHeader - Force the host header to a particular value
 * <li>whiteList - comma-separated list of allowed proxy destinations
 * <li>blackList - comma-separated list of forbidden proxy destinations
 * </ul>
 *
 * @see org.eclipse.jetty.server.handler.ConnectHandler
 */
public class ProxyServlet implements Servlet
{
    protected Logger _log;
    protected HttpClient _client;
    protected String _hostHeader;

    protected HashSet<String> _DontProxyHeaders = new HashSet<String>();
    {
        _DontProxyHeaders.add("proxy-connection");
        _DontProxyHeaders.add("connection");
        _DontProxyHeaders.add("keep-alive");
        _DontProxyHeaders.add("transfer-encoding");
        _DontProxyHeaders.add("te");
        _DontProxyHeaders.add("trailer");
        _DontProxyHeaders.add("proxy-authorization");
        _DontProxyHeaders.add("proxy-authenticate");
        _DontProxyHeaders.add("upgrade");
    }

    protected ServletConfig _config;
    protected ServletContext _context;
    protected HostMap<PathMap> _white = new HostMap<PathMap>();
    protected HostMap<PathMap> _black = new HostMap<PathMap>();

    /* ------------------------------------------------------------ */
    /*
     * (non-Javadoc)
     *
     * @see javax.servlet.Servlet#init(javax.servlet.ServletConfig)
     */
    public void init(ServletConfig config) throws ServletException
    {
        _config = config;
        _context = config.getServletContext();

        _hostHeader = config.getInitParameter("HostHeader");

        try
        {
            _log = createLogger(config);

            _client = createHttpClient(config);

            if (_context != null)
            {
                _context.setAttribute(config.getServletName() + ".ThreadPool",_client.getThreadPool());
                _context.setAttribute(config.getServletName() + ".HttpClient",_client);
            }

            String white = config.getInitParameter("whiteList");
            if (white != null)
            {
                parseList(white,_white);
            }
            String black = config.getInitParameter("blackList");
            if (black != null)
            {
                parseList(black,_black);
            }
        }
        catch (Exception e)
        {
            throw new ServletException(e);
        }
    }

    public void destroy()
    {
        try
        {
            _client.stop();
        }
        catch (Exception x)
        {
            _log.debug(x);
        }
    }


    /**
     * Create and return a logger based on the ServletConfig for use in the
     * proxy servlet
     *
     * @param config
     * @return Logger
     */
    protected Logger createLogger(ServletConfig config)
    {
        return Log.getLogger("org.eclipse.jetty.servlets." + config.getServletName());
    }

    /**
     * Create and return an HttpClientInstance
     *
     * @return HttpClient
     */
    protected HttpClient createHttpClientInstance()
    {
        return new HttpClient();
    }

    /**
     * Create and return an HttpClient based on ServletConfig
     *
     * By default this implementation will create an instance of the
     * HttpClient for use by this proxy servlet.
     *
     * @param config
     * @return HttpClient
     * @throws Exception
     */
    protected HttpClient createHttpClient(ServletConfig config) throws Exception
    {
        HttpClient client = createHttpClientInstance();
        client.setConnectorType(HttpClient.CONNECTOR_SELECT_CHANNEL);

        String t = config.getInitParameter("maxThreads");

        if (t != null)
        {
            client.setThreadPool(new QueuedThreadPool(Integer.parseInt(t)));
        }
        else
        {
            client.setThreadPool(new QueuedThreadPool());
        }

        ((QueuedThreadPool)client.getThreadPool()).setName(config.getServletName());

        t = config.getInitParameter("maxConnections");

        if (t != null)
        {
            client.setMaxConnectionsPerAddress(Integer.parseInt(t));
        }

        t = config.getInitParameter("timeout");

        if ( t != null )
        {
            client.setTimeout(Long.parseLong(t));
        }

        t = config.getInitParameter("idleTimeout");

        if ( t != null )
        {
            client.setIdleTimeout(Long.parseLong(t));
        }

        t = config.getInitParameter("requestHeaderSize");

        if ( t != null )
        {
            client.setRequestHeaderSize(Integer.parseInt(t));
        }

        t = config.getInitParameter("requestBufferSize");

        if ( t != null )
        {
            client.setRequestBufferSize(Integer.parseInt(t));
        }

        t = config.getInitParameter("responseHeaderSize");

        if ( t != null )
        {
            client.setResponseHeaderSize(Integer.parseInt(t));
        }

        t = config.getInitParameter("responseBufferSize");

        if ( t != null )
        {
            client.setResponseBufferSize(Integer.parseInt(t));
        }

        client.start();

        return client;
    }

    /* ------------------------------------------------------------ */
    /**
     * Helper function to process a parameter value containing a list of new entries and initialize the specified host map.
     *
     * @param list
     *            comma-separated list of new entries
     * @param hostMap
     *            target host map
     */
    private void parseList(String list, HostMap<PathMap> hostMap)
    {
        if (list != null && list.length() > 0)
        {
            int idx;
            String entry;

            StringTokenizer entries = new StringTokenizer(list,",");
            while (entries.hasMoreTokens())
            {
                entry = entries.nextToken();
                idx = entry.indexOf('/');

                String host = idx > 0?entry.substring(0,idx):entry;
                String path = idx > 0?entry.substring(idx):"/*";

                host = host.trim();
                PathMap pathMap = hostMap.get(host);
                if (pathMap == null)
                {
                    pathMap = new PathMap(true);
                    hostMap.put(host,pathMap);
                }
                if (path != null)
                {
                    pathMap.put(path,path);
                }
            }
        }
    }

    /* ------------------------------------------------------------ */
    /**
     * Check the request hostname and path against white- and blacklist.
     *
     * @param host
     *            hostname to check
     * @param path
     *            path to check
     * @return true if request is allowed to be proxied
     */
    public boolean validateDestination(String host, String path)
    {
        if (_white.size() > 0)
        {
            boolean match = false;

            Object whiteObj = _white.getLazyMatches(host);
            if (whiteObj != null)
            {
                List whiteList = (whiteObj instanceof List)?(List)whiteObj:Collections.singletonList(whiteObj);

                for (Object entry : whiteList)
                {
                    PathMap pathMap = ((Map.Entry<String, PathMap>)entry).getValue();
                    if (match = (pathMap != null && (pathMap.size() == 0 || pathMap.match(path) != null)))
                        break;
                }
            }

            if (!match)
                return false;
        }

        if (_black.size() > 0)
        {
            Object blackObj = _black.getLazyMatches(host);
            if (blackObj != null)
            {
                List blackList = (blackObj instanceof List)?(List)blackObj:Collections.singletonList(blackObj);

                for (Object entry : blackList)
                {
                    PathMap pathMap = ((Map.Entry<String, PathMap>)entry).getValue();
                    if (pathMap != null && (pathMap.size() == 0 || pathMap.match(path) != null))
                        return false;
                }
            }
        }

        return true;
    }

    /* ------------------------------------------------------------ */
    /*
     * (non-Javadoc)
     *
     * @see javax.servlet.Servlet#getServletConfig()
     */
    public ServletConfig getServletConfig()
    {
        return _config;
    }

    /* ------------------------------------------------------------ */
    /**
     * Get the hostHeader.
     *
     * @return the hostHeader
     */
    public String getHostHeader()
    {
        return _hostHeader;
    }

    /* ------------------------------------------------------------ */
    /**
     * Set the hostHeader.
     *
     * @param hostHeader
     *            the hostHeader to set
     */
    public void setHostHeader(String hostHeader)
    {
        _hostHeader = hostHeader;
    }

    /* ------------------------------------------------------------ */
    /*
     * (non-Javadoc)
     *
     * @see javax.servlet.Servlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
     */
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException
    {
        final int debug = _log.isDebugEnabled()?req.hashCode():0;

        final HttpServletRequest request = (HttpServletRequest)req;
        final HttpServletResponse response = (HttpServletResponse)res;

        if ("CONNECT".equalsIgnoreCase(request.getMethod()))
        {
            handleConnect(request,response);
        }
        else
        {
            final InputStream in = request.getInputStream();
            final OutputStream out = response.getOutputStream();

            final Continuation continuation = ContinuationSupport.getContinuation(request);

            if (!continuation.isInitial())
                response.sendError(HttpServletResponse.SC_GATEWAY_TIMEOUT); // Need better test that isInitial
            else
            {

                String uri = request.getRequestURI();
                if (request.getQueryString() != null)
                    uri += "?" + request.getQueryString();

                HttpURI url = proxyHttpURI(request,uri);

                if (debug != 0)
                    _log.debug(debug + " proxy " + uri + "-->" + url);

                if (url == null)
                {
                    response.sendError(HttpServletResponse.SC_FORBIDDEN);
                    return;
                }

                HttpExchange exchange = new HttpExchange()
                {
                    @Override
                    protected void onRequestCommitted() throws IOException
                    {
                    }

                    @Override
                    protected void onRequestComplete() throws IOException
                    {
                    }

                    @Override
                    protected void onResponseComplete() throws IOException
                    {
                        if (debug != 0)
                            _log.debug(debug + " complete");
                        continuation.complete();
                    }

                    @Override
                    protected void onResponseContent(Buffer content) throws IOException
                    {
                        if (debug != 0)
                            _log.debug(debug + " content" + content.length());
                        content.writeTo(out);
                    }

                    @Override
                    protected void onResponseHeaderComplete() throws IOException
                    {
                    }

                    @Override
                    protected void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException
                    {
                        if (debug != 0)
                            _log.debug(debug + " " + version + " " + status + " " + reason);

                        if (reason != null && reason.length() > 0)
                            response.setStatus(status,reason.toString());
                        else
                            response.setStatus(status);
                    }

                    @Override
                    protected void onResponseHeader(Buffer name, Buffer value) throws IOException
                    {
                        String nameString = name.toString();
                        String s = nameString.toLowerCase(Locale.ENGLISH);
                        if (!_DontProxyHeaders.contains(s) || (HttpHeaders.CONNECTION_BUFFER.equals(name) && HttpHeaderValues.CLOSE_BUFFER.equals(value)))
                        {
                            if (debug != 0)
                                _log.debug(debug + " " + name + ": " + value);

                            String filteredHeaderValue = filterResponseHeaderValue(nameString,value.toString(),request);
                            if (filteredHeaderValue != null && filteredHeaderValue.trim().length() > 0)
                            {
                                if (debug != 0)
                                    _log.debug(debug + " " + name + ": (filtered): " + filteredHeaderValue);
                                response.addHeader(nameString,filteredHeaderValue);
                            }
                        }
                        else if (debug != 0)
                            _log.debug(debug + " " + name + "! " + value);
                    }

                    @Override
                    protected void onConnectionFailed(Throwable ex)
                    {
                        handleOnConnectionFailed(ex,request,response);

                        // it is possible this might trigger before the
                        // continuation.suspend()
                        if (!continuation.isInitial())
                        {
                            continuation.complete();
                        }
                    }

                    @Override
                    protected void onException(Throwable ex)
                    {
                        if (ex instanceof EofException)
                        {
                            _log.ignore(ex);
                            //return;
                        }
                        handleOnException(ex,request,response);

                        // it is possible this might trigger before the
                        // continuation.suspend()
                        if (!continuation.isInitial())
                        {
                            continuation.complete();
                        }
                    }

                    @Override
                    protected void onExpire()
                    {
                        handleOnExpire(request,response);
                        continuation.complete();
                    }

                };

                exchange.setScheme(HttpSchemes.HTTPS.equals(request.getScheme())?HttpSchemes.HTTPS_BUFFER:HttpSchemes.HTTP_BUFFER);
                exchange.setMethod(request.getMethod());
                exchange.setURL(url.toString());
                exchange.setVersion(request.getProtocol());


                if (debug != 0)
                    _log.debug(debug + " " + request.getMethod() + " " + url + " " + request.getProtocol());

                // check connection header
                String connectionHdr = request.getHeader("Connection");
                if (connectionHdr != null)
                {
                    connectionHdr = connectionHdr.toLowerCase(Locale.ENGLISH);
                    if (connectionHdr.indexOf("keep-alive") < 0 && connectionHdr.indexOf("close") < 0)
                        connectionHdr = null;
                }

                // force host
                if (_hostHeader != null)
                    exchange.setRequestHeader("Host",_hostHeader);

                // copy headers
                boolean xForwardedFor = false;
                boolean hasContent = false;
                long contentLength = -1;
                Enumeration<?> enm = request.getHeaderNames();
                while (enm.hasMoreElements())
                {
                    // TODO could be better than this!
                    String hdr = (String)enm.nextElement();
                    String lhdr = hdr.toLowerCase(Locale.ENGLISH);

                    if ("transfer-encoding".equals(lhdr))
                    {
                        if (request.getHeader("transfer-encoding").indexOf("chunk")>=0)
                            hasContent = true;
                    }
                    
                    if (_DontProxyHeaders.contains(lhdr))
                        continue;
                    if (connectionHdr != null && connectionHdr.indexOf(lhdr) >= 0)
                        continue;
                    if (_hostHeader != null && "host".equals(lhdr))
                        continue;

                    if ("content-type".equals(lhdr))
                        hasContent = true;
                    else if ("content-length".equals(lhdr))
                    {
                        contentLength = request.getContentLength();
                        exchange.setRequestHeader(HttpHeaders.CONTENT_LENGTH,Long.toString(contentLength));
                        if (contentLength > 0)
                            hasContent = true;
                    }
                    else if ("x-forwarded-for".equals(lhdr))
                        xForwardedFor = true;

                    Enumeration<?> vals = request.getHeaders(hdr);
                    while (vals.hasMoreElements())
                    {
                        String val = (String)vals.nextElement();
                        if (val != null)
                        {
                            if (debug != 0)
                                _log.debug(debug + " " + hdr + ": " + val);

                            exchange.setRequestHeader(hdr,val);
                        }
                    }
                }

                // Proxy headers
                exchange.setRequestHeader("Via","1.1 (jetty)");
                if (!xForwardedFor)
                {
                    exchange.addRequestHeader("X-Forwarded-For",request.getRemoteAddr());
                    exchange.addRequestHeader("X-Forwarded-Proto",request.getScheme());
                    exchange.addRequestHeader("X-Forwarded-Host",request.getHeader("Host"));
                    exchange.addRequestHeader("X-Forwarded-Server",request.getLocalName());
                }

                if (hasContent)
                {
                    exchange.setRequestContentSource(in);
                }

                customizeExchange(exchange, request);

                /*
                 * we need to set the timeout on the continuation to take into
                 * account the timeout of the HttpClient and the HttpExchange
                 */
                long ctimeout = (_client.getTimeout() > exchange.getTimeout()) ? _client.getTimeout() : exchange.getTimeout();

                // continuation fudge factor of 1000, underlying components
                // should fail/expire first from exchange
                if ( ctimeout == 0 )
                {
                    continuation.setTimeout(0);  // ideally never times out
                }
                else
                {
                    continuation.setTimeout(ctimeout + 1000);
                }

                customizeContinuation(continuation);

                continuation.suspend(response);
                _client.send(exchange);

            }
        }
    }

    /* ------------------------------------------------------------ */
    public void handleConnect(HttpServletRequest request, HttpServletResponse response) throws IOException
    {
        String uri = request.getRequestURI();

        String port = "";
        String host = "";

        int c = uri.indexOf(':');
        if (c >= 0)
        {
            port = uri.substring(c + 1);
            host = uri.substring(0,c);
            if (host.indexOf('/') > 0)
                host = host.substring(host.indexOf('/') + 1);
        }

        // TODO - make this async!

        InetSocketAddress inetAddress = new InetSocketAddress(host,Integer.parseInt(port));

        // if (isForbidden(HttpMessage.__SSL_SCHEME,addrPort.getHost(),addrPort.getPort(),false))
        // {
        // sendForbid(request,response,uri);
        // }
        // else
        {
            InputStream in = request.getInputStream();
            OutputStream out = response.getOutputStream();

            Socket socket = new Socket(inetAddress.getAddress(),inetAddress.getPort());

            response.setStatus(200);
            response.setHeader("Connection","close");
            response.flushBuffer();
            // TODO prevent real close!

            IO.copyThread(socket.getInputStream(),out);
            IO.copy(in,socket.getOutputStream());
        }
    }

    /* ------------------------------------------------------------ */
    protected HttpURI proxyHttpURI(HttpServletRequest request, String uri) throws MalformedURLException
    {
        return proxyHttpURI(request.getScheme(), request.getServerName(), request.getServerPort(), uri);
    }

    protected HttpURI proxyHttpURI(String scheme, String serverName, int serverPort, String uri) throws MalformedURLException
    {
        if (!validateDestination(serverName,uri))
            return null;

        return new HttpURI(scheme + "://" + serverName + ":" + serverPort + uri);
    }

    /*
     * (non-Javadoc)
     *
     * @see javax.servlet.Servlet#getServletInfo()
     */
    public String getServletInfo()
    {
        return "Proxy Servlet";
    }


    /**
     * Extension point for subclasses to customize an exchange. Useful for setting timeouts etc. The default implementation does nothing.
     *
     * @param exchange
     * @param request
     */
    protected void customizeExchange(HttpExchange exchange, HttpServletRequest request)
    {

    }

    /**
     * Extension point for subclasses to customize the Continuation after it's initial creation in the service method. Useful for setting timeouts etc. The
     * default implementation does nothing.
     *
     * @param continuation
     */
    protected void customizeContinuation(Continuation continuation)
    {

    }

    /**
     * Extension point for custom handling of an HttpExchange's onConnectionFailed method. The default implementation delegates to
     * {@link #handleOnException(Throwable, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)}
     *
     * @param ex
     * @param request
     * @param response
     */
    protected void handleOnConnectionFailed(Throwable ex, HttpServletRequest request, HttpServletResponse response)
    {
        handleOnException(ex,request,response);
    }

    /**
     * Extension point for custom handling of an HttpExchange's onException method. The default implementation sets the response status to
     * HttpServletResponse.SC_INTERNAL_SERVER_ERROR (503)
     *
     * @param ex
     * @param request
     * @param response
     */
    protected void handleOnException(Throwable ex, HttpServletRequest request, HttpServletResponse response)
    {
        if (ex instanceof IOException)
        {
            _log.warn(ex.toString());
            _log.debug(ex);
        }
        else
            _log.warn(ex);
        
        if (!response.isCommitted())
        {
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * Extension point for custom handling of an HttpExchange's onExpire method. The default implementation sets the response status to
     * HttpServletResponse.SC_GATEWAY_TIMEOUT (504)
     *
     * @param request
     * @param response
     */
    protected void handleOnExpire(HttpServletRequest request, HttpServletResponse response)
    {
        if (!response.isCommitted())
        {
            response.setStatus(HttpServletResponse.SC_GATEWAY_TIMEOUT);
        }
    }

    /**
     * Extension point for remote server response header filtering. The default implementation returns the header value as is. If null is returned, this header
     * won't be forwarded back to the client.
     * 
     * @param headerName
     * @param headerValue
     * @param request
     * @return filteredHeaderValue
     */
    protected String filterResponseHeaderValue(String headerName, String headerValue, HttpServletRequest request)
    {
        return headerValue;
    }

    /**
     * Transparent Proxy.
     * 
     * This convenience extension to ProxyServlet configures the servlet as a transparent proxy. The servlet is configured with init parameters:
     * <ul>
     * <li>ProxyTo - a URI like http://host:80/context to which the request is proxied.
     * <li>Prefix - a URI prefix that is striped from the start of the forwarded URI.
     * </ul>
     * For example, if a request was received at /foo/bar and the ProxyTo was http://host:80/context and the Prefix was /foo, then the request would be proxied
     * to http://host:80/context/bar
     * 
     */
    public static class Transparent extends ProxyServlet
    {
        String _prefix;
        String _proxyTo;

        public Transparent()
        {
        }

        public Transparent(String prefix, String host, int port)
        {
            this(prefix,"http",host,port,null);
        }

        public Transparent(String prefix, String schema, String host, int port, String path)
        {
            try
            {
                if (prefix != null)
                {
                    _prefix = new URI(prefix).normalize().toString();
                }
                _proxyTo = new URI(schema,null,host,port,path,null,null).normalize().toString();
            }
            catch (URISyntaxException ex)
            {
                _log.debug("Invalid URI syntax",ex);
            }
        }

        @Override
        public void init(ServletConfig config) throws ServletException
        {
            super.init(config);

            String prefix = config.getInitParameter("Prefix");
            _prefix = prefix == null?_prefix:prefix;

            // Adjust prefix value to account for context path
            String contextPath = _context.getContextPath();
            _prefix = _prefix == null?contextPath:(contextPath + _prefix);

            String proxyTo = config.getInitParameter("ProxyTo");
            _proxyTo = proxyTo == null?_proxyTo:proxyTo;

            if (_proxyTo == null)
                throw new UnavailableException("ProxyTo parameter is requred.");

            if (!_prefix.startsWith("/"))
                throw new UnavailableException("Prefix parameter must start with a '/'.");

            _log.info(config.getServletName() + " @ " + _prefix + " to " + _proxyTo);
        }

        @Override
        protected HttpURI proxyHttpURI(final String scheme, final String serverName, int serverPort, final String uri) throws MalformedURLException
        {
            try
            {
                if (!uri.startsWith(_prefix))
                    return null;

                URI dstUri = new URI(_proxyTo + uri.substring(_prefix.length())).normalize();

                if (!validateDestination(dstUri.getHost(),dstUri.getPath()))
                    return null;

                return new HttpURI(dstUri.toString());
            }
            catch (URISyntaxException ex)
            {
                throw new MalformedURLException(ex.getMessage());
            }
        }
    }
}