//
   //  ========================================================================
   //  Copyright (c) 1995-2012 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 (_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());
             }
         }
     }
 }