src/com/google/enterprise/adaptor/ReverseProxyHandler.java - plexi - Git at Google

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Licensed 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.

 package com.google.enterprise.adaptor;

 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Sets;

 import com.sun.net.httpserver.HttpExchange;
 import com.sun.net.httpserver.HttpHandler;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.Authenticator;
 import java.net.HttpURLConnection;
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 /**
  * An HTTP reverse proxy. This class uses HttpURLConnection internally, so the
  * default {@link Authenticator} must be {@code null} for proper operation. The
  * implementation is known to drop the response body for 401 responses to POST
  * requests.
  */
 class ReverseProxyHandler implements HttpHandler {
   // The Hop-by-hop headers that are connection-local, as defined by RFC 2616
   // Section 13.5.1. As mentioned in the section, additional headers can be
   // specified in the Connection header.
   private static final Set<String> PREDEFINED_HOP_BY_HOP_HEADERS
       = ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER).add(
           "Connection",
           "Host", // Because this is a reverse proxy.
           "Keep-Alive",
           "Proxy-Authenticate",
           "Proxy-Authorization",
           "TE",
           "Trailers",
           "Transfer-Encoding",
           "Upgrade").build();

   private static final Logger log
       = Logger.getLogger(HttpExchanges.class.getName());

   private final URI destinationBase;

   public ReverseProxyHandler(URI destinationBase) {
     if (destinationBase == null) {
       throw new NullPointerException();
     }
     this.destinationBase = destinationBase;
     if (destinationBase.getScheme() == null || destinationBase.getHost() == null
         || destinationBase.getPath() == null) {
       throw new IllegalArgumentException(
           "destinationBase must contain a scheme, host, and path");
     }
   }

   @Override
   public void handle(HttpExchange ex) throws IOException {
     URI dest = computeProxyDestination(ex);

     // Set up request
     HttpURLConnection conn = (HttpURLConnection) dest.toURL().openConnection();
     conn.setRequestMethod(ex.getRequestMethod());
     conn.setAllowUserInteraction(false);
     conn.setInstanceFollowRedirects(false);
     // This adds Cache-Control: no-cache and Pragma: no-cache if those headers
     // keys aren't already there. It is unfortunate that it modifies the
     // request, however, the presense of these headers shouldn't have an impact
     // because they are targeted to proxy servers, not the application server.
     // See RFC 2616 Section 14.9.1 and 14.32.
     conn.setUseCaches(false);
     // HttpUrlConnection will add Accept and User-Agent headers if they aren't
     // already there. Luckily they are almost always there.
     copyRequestHeaders(ex, conn);
     conn.addRequestProperty("X-Forwarded-For", getClientIp(ex));

     // As defined in RFC 2616 Section 4.3
     boolean hasRequestBody
         = ex.getRequestHeaders().containsKey("Content-Length")
         || ex.getRequestHeaders().containsKey("Transfer-Encoding");

     conn.setDoOutput(hasRequestBody);
     // Input is required for getResponseCode()
     conn.setDoInput(true);

     if (hasRequestBody) {
       String strContentLength
           = ex.getRequestHeaders().getFirst("Content-Length");
       long contentLength = -1;
       if (strContentLength != null) {
         try {
           contentLength = Long.parseLong(strContentLength);
         } catch (NumberFormatException e) {
           // Keep contentLength = -1
         }
       }
       // Enable streaming mode on the connection to prevent entire request body
       // from being buffered. Streaming mode also disables automatic
       // authentication.
       if (contentLength < 0) {
         conn.setChunkedStreamingMode(-1);
       } else {
         // TODO(ejona): remove cast once we depend on Java 7.
         conn.setFixedLengthStreamingMode((int) contentLength);
       }
     } else {
       // It is essential that no authentication happens. Unfortunately for
       // requests with no body (like GET), it seems impossible to detect if
       // authentication could be or was performed and impossible to prevent it
       // for a particular request.
       //
       // Thus, we disable authentication globally, which could easily break
       // other code's assumptions. However, the hope is that the other code will
       // begin breaking and we have a chance at discovering the incompatibility
       // between the two pieces of code, instead of silently offering content to
       // requesters that they are not authenticated for.
       Authenticator.setDefault(null);
     }

     // Actually issue the request, and copy the data back
     conn.connect();
     if (hasRequestBody) {
       try {
         IOHelper.copyStream(ex.getRequestBody(), conn.getOutputStream());
         ex.getRequestBody().close();
         conn.getOutputStream().close();
       } catch (IOException e) {
         // TODO(ejona): determine if there is a more graceful way to clean up
         conn.disconnect();
         throw e;
       }
     }

     InputStream inputStream = conn.getResponseCode() >= 400
         ? conn.getErrorStream() : conn.getInputStream();
     // InputStream is null when responseCode == 401 and doing streaming, because
     // HttpURLConnection does not consider its state "connected". Unfortunately,
     // that means that we will lose the content for 401 responses for POST.
     if (conn.getResponseCode() == 401 && inputStream == null) {
       inputStream = new ByteArrayInputStream(new byte[0]);
     }

     // As defined in RFC 2616 Section 4.3
     boolean hasResponseBody = !("HEAD".equalsIgnoreCase(ex.getRequestMethod())
         || conn.getResponseCode() / 100 == 1 // 1xx Informational
         || conn.getResponseCode() == 204 // No Content
         || conn.getResponseCode() == 304); // Not Modified

     try {
       copyResponseHeaders(conn, ex);

       if (!hasResponseBody) {
         ex.sendResponseHeaders(conn.getResponseCode(), -1);
       } else {
         int contentLength = conn.getContentLength();
         if (contentLength <= 0) {
           // If the content length was unknown (-1) or if it was zero, then we
           // are forced to use chunked transfer encoding.
           contentLength = 0;
         }
         ex.sendResponseHeaders(conn.getResponseCode(), contentLength);
         IOHelper.copyStream(inputStream, ex.getResponseBody());
       }
       // Don't close in a finally because that would be a successful response.
       // If there is an error we want the server to kill the connection, which
       // informs the client that something went wrong.
       ex.close();
     } finally {
       inputStream.close();
     }
   }

   /**
    * Compute the URI the proxy should send a request to, to proxy the provided
    * request.
    */
   private URI computeProxyDestination(HttpExchange ex) {
     URI req = HttpExchanges.getRequestUri(ex);
     final String basePath = ex.getHttpContext().getPath();
     if (!req.getPath().startsWith(basePath)) {
       throw new AssertionError();
     }
     String lastPartOfPath = req.getPath().substring(basePath.length());
     try {
       return new URI(destinationBase.getScheme(),
           destinationBase.getAuthority(),
           destinationBase.getPath() + lastPartOfPath, req.getQuery(),
           req.getFragment());
     } catch (URISyntaxException e) {
       throw new AssertionError(e);
     }
   }

   /**
    * Compute the equivalent URI to this proxy provided a possible URI pointing
    * to the destination server.
    *
    * <p>Redirects and similar require absolute URIs, so the destination server
    * is forced to expose its hostname and IP. We could pass the original
    * Host in the request (a la Apache's ProxyPreserveHost), but that is not
    * sufficent because it can't specify the path. So instead, we rewrite
    * such response headers when they match the destinationUri so they point to
    * the proxy instead of the destination (a la Apache's ProxyPassReverse).
    */
   private String computeReverseProxyDestination(HttpExchange ex,
       String location) {
     URI uri = null;
     try {
       uri = new URI(location);
     } catch (URISyntaxException e) {
       log.log(Level.INFO, "Could not parse value from header: " + location, e);
       return location;
     }
     URI base = destinationBase;
     // Check if the value starts with destinationBase. Use URI so that we
     // can correctly take case into consideration as appropriate.
     if (!(base.getScheme().equalsIgnoreCase(uri.getScheme())
         && base.getHost().equalsIgnoreCase(uri.getHost())
         && base.getPort() == uri.getPort()
         && uri.getPath() != null
         // This is correctly case-sensitive.
         && uri.getPath().startsWith(base.getPath()))) {
       return location;
     }
     String lastPartOfPath = uri.getPath().substring(base.getPath().length());
     URI requestUri = HttpExchanges.getRequestUri(ex);
     try {
       return new URI(requestUri.getScheme(), requestUri.getAuthority(),
           ex.getHttpContext().getPath() + lastPartOfPath, uri.getQuery(),
           uri.getFragment()).toASCIIString();
     } catch (URISyntaxException e) {
       throw new AssertionError(e);
     }
   }

   private void copyRequestHeaders(HttpExchange from, HttpURLConnection to) {
     Set<String> requestHopByHopHeaders
         = getHopByHopHeaders(from.getRequestHeaders().get("Connection"));
     for (Map.Entry<String, List<String>> me
         : from.getRequestHeaders().entrySet()) {
       if (requestHopByHopHeaders.contains(me.getKey())) {
         continue;
       }
       for (String value : me.getValue()) {
         to.addRequestProperty(me.getKey(), value);
       }
     }
   }

   private void copyResponseHeaders(HttpURLConnection from, HttpExchange to) {
     Set<String> responseHopByHopHeaders
         = getHopByHopHeaders(from.getHeaderFields().get("Connection"));
     // HttpURLConnection.getHeaderFields() reverses the order of repeated
     // headers' values, so we avoid it. Specifically,
     // sun.net.www.MessageHeader.filterAndAddHeaders() loops through the
     // headers in reverse order while building the map.
     for (int i = 0;; i++) {
       String key = from.getHeaderFieldKey(i);
       String value = from.getHeaderField(i);
       if (value == null) {
         break; // Reached end
       }
       if (key == null) {
         continue; // Value is the HTTP status line, which we want to skip
       }
       if (responseHopByHopHeaders.contains(key)) {
         continue;
       }
       if ("Location".equalsIgnoreCase(key)
           || "Content-Location".equalsIgnoreCase(key)
           || "URI".equalsIgnoreCase(key)) {
         value = computeReverseProxyDestination(to, value);
       }
       to.getResponseHeaders().add(key, value);
     }
   }

   private String getClientIp(HttpExchange ex) {
     InetSocketAddress clientAddr = ex.getRemoteAddress();
     if (clientAddr.isUnresolved()) {
       log.log(Level.WARNING, "Could not determine client's IP");
       return "unknown";
     }
     return clientAddr.getAddress().getHostAddress();
   }

   private Set<String> getHopByHopHeaders(List<String> connectionValues) {
     List<String> rawConnectionHeaders
         = HttpExchanges.splitHeaderValues(connectionValues);
     if (rawConnectionHeaders == null) {
       rawConnectionHeaders = Collections.emptyList();
     }
     Set<String> connectionHeaders
         = ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER)
         .addAll(rawConnectionHeaders).build();
     return Sets.union(PREDEFINED_HOP_BY_HOP_HEADERS, connectionHeaders);
   }
 }
	// Copyright 2014 Google Inc. All Rights Reserved.
	//
	// Licensed 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.

	package com.google.enterprise.adaptor;

	import com.google.common.collect.ImmutableSortedSet;
	import com.google.common.collect.Sets;

	import com.sun.net.httpserver.HttpExchange;
	import com.sun.net.httpserver.HttpHandler;

	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.Authenticator;
	import java.net.HttpURLConnection;
	import java.net.InetSocketAddress;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	/**
	* An HTTP reverse proxy. This class uses HttpURLConnection internally, so the
	* default {@link Authenticator} must be {@code null} for proper operation. The
	* implementation is known to drop the response body for 401 responses to POST
	* requests.
	*/
	class ReverseProxyHandler implements HttpHandler {
	// The Hop-by-hop headers that are connection-local, as defined by RFC 2616
	// Section 13.5.1. As mentioned in the section, additional headers can be
	// specified in the Connection header.
	private static final Set<String> PREDEFINED_HOP_BY_HOP_HEADERS
	= ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER).add(
	"Connection",
	"Host", // Because this is a reverse proxy.
	"Keep-Alive",
	"Proxy-Authenticate",
	"Proxy-Authorization",
	"TE",
	"Trailers",
	"Transfer-Encoding",
	"Upgrade").build();

	private static final Logger log
	= Logger.getLogger(HttpExchanges.class.getName());

	private final URI destinationBase;

	public ReverseProxyHandler(URI destinationBase) {
	if (destinationBase == null) {
	throw new NullPointerException();
	}
	this.destinationBase = destinationBase;
	if (destinationBase.getScheme() == null \|\| destinationBase.getHost() == null
	\|\| destinationBase.getPath() == null) {
	throw new IllegalArgumentException(
	"destinationBase must contain a scheme, host, and path");
	}
	}

	@Override
	public void handle(HttpExchange ex) throws IOException {
	URI dest = computeProxyDestination(ex);

	// Set up request
	HttpURLConnection conn = (HttpURLConnection) dest.toURL().openConnection();
	conn.setRequestMethod(ex.getRequestMethod());
	conn.setAllowUserInteraction(false);
	conn.setInstanceFollowRedirects(false);
	// This adds Cache-Control: no-cache and Pragma: no-cache if those headers
	// keys aren't already there. It is unfortunate that it modifies the
	// request, however, the presense of these headers shouldn't have an impact
	// because they are targeted to proxy servers, not the application server.
	// See RFC 2616 Section 14.9.1 and 14.32.
	conn.setUseCaches(false);
	// HttpUrlConnection will add Accept and User-Agent headers if they aren't
	// already there. Luckily they are almost always there.
	copyRequestHeaders(ex, conn);
	conn.addRequestProperty("X-Forwarded-For", getClientIp(ex));

	// As defined in RFC 2616 Section 4.3
	boolean hasRequestBody
	= ex.getRequestHeaders().containsKey("Content-Length")
	\|\| ex.getRequestHeaders().containsKey("Transfer-Encoding");

	conn.setDoOutput(hasRequestBody);
	// Input is required for getResponseCode()
	conn.setDoInput(true);

	if (hasRequestBody) {
	String strContentLength
	= ex.getRequestHeaders().getFirst("Content-Length");
	long contentLength = -1;
	if (strContentLength != null) {
	try {
	contentLength = Long.parseLong(strContentLength);
	} catch (NumberFormatException e) {
	// Keep contentLength = -1
	}
	}
	// Enable streaming mode on the connection to prevent entire request body
	// from being buffered. Streaming mode also disables automatic
	// authentication.
	if (contentLength < 0) {
	conn.setChunkedStreamingMode(-1);
	} else {
	// TODO(ejona): remove cast once we depend on Java 7.
	conn.setFixedLengthStreamingMode((int) contentLength);
	}
	} else {
	// It is essential that no authentication happens. Unfortunately for
	// requests with no body (like GET), it seems impossible to detect if
	// authentication could be or was performed and impossible to prevent it
	// for a particular request.
	//
	// Thus, we disable authentication globally, which could easily break
	// other code's assumptions. However, the hope is that the other code will
	// begin breaking and we have a chance at discovering the incompatibility
	// between the two pieces of code, instead of silently offering content to
	// requesters that they are not authenticated for.
	Authenticator.setDefault(null);
	}

	// Actually issue the request, and copy the data back
	conn.connect();
	if (hasRequestBody) {
	try {
	IOHelper.copyStream(ex.getRequestBody(), conn.getOutputStream());
	ex.getRequestBody().close();
	conn.getOutputStream().close();
	} catch (IOException e) {
	// TODO(ejona): determine if there is a more graceful way to clean up
	conn.disconnect();
	throw e;
	}
	}

	InputStream inputStream = conn.getResponseCode() >= 400
	? conn.getErrorStream() : conn.getInputStream();
	// InputStream is null when responseCode == 401 and doing streaming, because
	// HttpURLConnection does not consider its state "connected". Unfortunately,
	// that means that we will lose the content for 401 responses for POST.
	if (conn.getResponseCode() == 401 && inputStream == null) {
	inputStream = new ByteArrayInputStream(new byte[0]);
	}

	// As defined in RFC 2616 Section 4.3
	boolean hasResponseBody = !("HEAD".equalsIgnoreCase(ex.getRequestMethod())
	\|\| conn.getResponseCode() / 100 == 1 // 1xx Informational
	\|\| conn.getResponseCode() == 204 // No Content
	\|\| conn.getResponseCode() == 304); // Not Modified

	try {
	copyResponseHeaders(conn, ex);

	if (!hasResponseBody) {
	ex.sendResponseHeaders(conn.getResponseCode(), -1);
	} else {
	int contentLength = conn.getContentLength();
	if (contentLength <= 0) {
	// If the content length was unknown (-1) or if it was zero, then we
	// are forced to use chunked transfer encoding.
	contentLength = 0;
	}
	ex.sendResponseHeaders(conn.getResponseCode(), contentLength);
	IOHelper.copyStream(inputStream, ex.getResponseBody());
	}
	// Don't close in a finally because that would be a successful response.
	// If there is an error we want the server to kill the connection, which
	// informs the client that something went wrong.
	ex.close();
	} finally {
	inputStream.close();
	}
	}

	/**
	* Compute the URI the proxy should send a request to, to proxy the provided
	* request.
	*/
	private URI computeProxyDestination(HttpExchange ex) {
	URI req = HttpExchanges.getRequestUri(ex);
	final String basePath = ex.getHttpContext().getPath();
	if (!req.getPath().startsWith(basePath)) {
	throw new AssertionError();
	}
	String lastPartOfPath = req.getPath().substring(basePath.length());
	try {
	return new URI(destinationBase.getScheme(),
	destinationBase.getAuthority(),
	destinationBase.getPath() + lastPartOfPath, req.getQuery(),
	req.getFragment());
	} catch (URISyntaxException e) {
	throw new AssertionError(e);
	}
	}

	/**
	* Compute the equivalent URI to this proxy provided a possible URI pointing
	* to the destination server.
	*
	* <p>Redirects and similar require absolute URIs, so the destination server
	* is forced to expose its hostname and IP. We could pass the original
	* Host in the request (a la Apache's ProxyPreserveHost), but that is not
	* sufficent because it can't specify the path. So instead, we rewrite
	* such response headers when they match the destinationUri so they point to
	* the proxy instead of the destination (a la Apache's ProxyPassReverse).
	*/
	private String computeReverseProxyDestination(HttpExchange ex,
	String location) {
	URI uri = null;
	try {
	uri = new URI(location);
	} catch (URISyntaxException e) {
	log.log(Level.INFO, "Could not parse value from header: " + location, e);
	return location;
	}
	URI base = destinationBase;
	// Check if the value starts with destinationBase. Use URI so that we
	// can correctly take case into consideration as appropriate.
	if (!(base.getScheme().equalsIgnoreCase(uri.getScheme())
	&& base.getHost().equalsIgnoreCase(uri.getHost())
	&& base.getPort() == uri.getPort()
	&& uri.getPath() != null
	// This is correctly case-sensitive.
	&& uri.getPath().startsWith(base.getPath()))) {
	return location;
	}
	String lastPartOfPath = uri.getPath().substring(base.getPath().length());
	URI requestUri = HttpExchanges.getRequestUri(ex);
	try {
	return new URI(requestUri.getScheme(), requestUri.getAuthority(),
	ex.getHttpContext().getPath() + lastPartOfPath, uri.getQuery(),
	uri.getFragment()).toASCIIString();
	} catch (URISyntaxException e) {
	throw new AssertionError(e);
	}
	}

	private void copyRequestHeaders(HttpExchange from, HttpURLConnection to) {
	Set<String> requestHopByHopHeaders
	= getHopByHopHeaders(from.getRequestHeaders().get("Connection"));
	for (Map.Entry<String, List<String>> me
	: from.getRequestHeaders().entrySet()) {
	if (requestHopByHopHeaders.contains(me.getKey())) {
	continue;
	}
	for (String value : me.getValue()) {
	to.addRequestProperty(me.getKey(), value);
	}
	}
	}

	private void copyResponseHeaders(HttpURLConnection from, HttpExchange to) {
	Set<String> responseHopByHopHeaders
	= getHopByHopHeaders(from.getHeaderFields().get("Connection"));
	// HttpURLConnection.getHeaderFields() reverses the order of repeated
	// headers' values, so we avoid it. Specifically,
	// sun.net.www.MessageHeader.filterAndAddHeaders() loops through the
	// headers in reverse order while building the map.
	for (int i = 0;; i++) {
	String key = from.getHeaderFieldKey(i);
	String value = from.getHeaderField(i);
	if (value == null) {
	break; // Reached end
	}
	if (key == null) {
	continue; // Value is the HTTP status line, which we want to skip
	}
	if (responseHopByHopHeaders.contains(key)) {
	continue;
	}
	if ("Location".equalsIgnoreCase(key)
	\|\| "Content-Location".equalsIgnoreCase(key)
	\|\| "URI".equalsIgnoreCase(key)) {
	value = computeReverseProxyDestination(to, value);
	}
	to.getResponseHeaders().add(key, value);
	}
	}

	private String getClientIp(HttpExchange ex) {
	InetSocketAddress clientAddr = ex.getRemoteAddress();
	if (clientAddr.isUnresolved()) {
	log.log(Level.WARNING, "Could not determine client's IP");
	return "unknown";
	}
	return clientAddr.getAddress().getHostAddress();
	}

	private Set<String> getHopByHopHeaders(List<String> connectionValues) {
	List<String> rawConnectionHeaders
	= HttpExchanges.splitHeaderValues(connectionValues);
	if (rawConnectionHeaders == null) {
	rawConnectionHeaders = Collections.emptyList();
	}
	Set<String> connectionHeaders
	= ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER)
	.addAll(rawConnectionHeaders).build();
	return Sets.union(PREDEFINED_HOP_BY_HOP_HEADERS, connectionHeaders);
	}
	}