luni/src/main/java/libcore/net/http/HttpURLConnectionImpl.java - platform/libcore - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package libcore.net.http;

 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Authenticator;
 import java.net.HttpRetryException;
 import java.net.HttpURLConnection;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.PasswordAuthentication;
 import java.net.ProtocolException;
 import java.net.Proxy;
 import java.net.SocketPermission;
 import java.net.URL;
 import java.nio.charset.Charsets;
 import java.security.Permission;
 import java.util.List;
 import java.util.Map;
 import libcore.io.Base64;
 import libcore.io.IoUtils;

 /**
  * This implementation uses HttpEngine to send requests and receive responses.
  * This class may use multiple HttpEngines to follow redirects, authentication
  * retries, etc. to retrieve the final response body.
  *
  * <h3>What does 'connected' mean?</h3>
  * This class inherits a {@code connected} field from the superclass. That field
  * is <strong>not</strong> used to indicate not whether this URLConnection is
  * currently connected. Instead, it indicates whether a connection has ever been
  * attempted. Once a connection has been attempted, certain properties (request
  * header fields, request method, etc.) are immutable. Test the {@code
  * connection} field on this class for null/non-null to determine of an instance
  * is currently connected to a server.
  */
 class HttpURLConnectionImpl extends HttpURLConnection {

     private final int defaultPort;

     private Proxy proxy;

     private final RawHeaders rawRequestHeaders = new RawHeaders();

     private int redirectionCount;

     protected IOException httpEngineFailure;
     protected HttpEngine httpEngine;

     protected HttpURLConnectionImpl(URL url, int port) {
         super(url);
         defaultPort = port;
     }

     protected HttpURLConnectionImpl(URL url, int port, Proxy proxy) {
         this(url, port);
         this.proxy = proxy;
     }

     @Override public final void connect() throws IOException {
         initHttpEngine();
         try {
             httpEngine.sendRequest();
         } catch (IOException e) {
             httpEngineFailure = e;
             throw e;
         }
     }

     @Override public final void disconnect() {
         // Calling disconnect() before a connection exists should have no effect.
         if (httpEngine != null) {
             // We close the response body here instead of in
             // HttpEngine.release because that is called when input
             // has been completely read from the underlying socket.
             // However the response body can be a GZIPInputStream that
             // still has unread data.
             if (httpEngine.hasResponse()) {
                 IoUtils.closeQuietly(httpEngine.getResponseBody());
             }
             httpEngine.release(false);
         }
     }

     /**
      * Returns an input stream from the server in the case of error such as the
      * requested file (txt, htm, html) is not found on the remote server.
      */
     @Override public final InputStream getErrorStream() {
         try {
             HttpEngine response = getResponse();
             if (response.hasResponseBody()
                     && response.getResponseCode() >= HTTP_BAD_REQUEST) {
                 return response.getResponseBody();
             }
             return null;
         } catch (IOException e) {
             return null;
         }
     }

     /**
      * Returns the value of the field at {@code position}. Returns null if there
      * are fewer than {@code position} headers.
      */
     @Override public final String getHeaderField(int position) {
         try {
             return getResponse().getResponseHeaders().getHeaders().getValue(position);
         } catch (IOException e) {
             return null;
         }
     }

     /**
      * Returns the value of the field corresponding to the {@code fieldName}, or
      * null if there is no such field. If the field has multiple values, the
      * last value is returned.
      */
     @Override public final String getHeaderField(String fieldName) {
         try {
             RawHeaders rawHeaders = getResponse().getResponseHeaders().getHeaders();
             return fieldName == null
                     ? rawHeaders.getStatusLine()
                     : rawHeaders.get(fieldName);
         } catch (IOException e) {
             return null;
         }
     }

     @Override public final String getHeaderFieldKey(int position) {
         try {
             return getResponse().getResponseHeaders().getHeaders().getFieldName(position);
         } catch (IOException e) {
             return null;
         }
     }

     @Override public final Map<String, List<String>> getHeaderFields() {
         try {
             return getResponse().getResponseHeaders().getHeaders().toMultimap();
         } catch (IOException e) {
             return null;
         }
     }

     @Override public final Map<String, List<String>> getRequestProperties() {
         if (connected) {
             throw new IllegalStateException(
                     "Cannot access request header fields after connection is set");
         }
         return rawRequestHeaders.toMultimap();
     }

     @Override public final InputStream getInputStream() throws IOException {
         if (!doInput) {
             throw new ProtocolException("This protocol does not support input");
         }

         HttpEngine response = getResponse();

         /*
          * if the requested file does not exist, throw an exception formerly the
          * Error page from the server was returned if the requested file was
          * text/html this has changed to return FileNotFoundException for all
          * file types
          */
         if (getResponseCode() >= HTTP_BAD_REQUEST) {
             throw new FileNotFoundException(url.toString());
         }

         InputStream result = response.getResponseBody();
         if (result == null) {
             throw new IOException("No response body exists; responseCode=" + getResponseCode());
         }
         return result;
     }

     @Override public final OutputStream getOutputStream() throws IOException {
         connect();

         OutputStream result = httpEngine.getRequestBody();
         if (result == null) {
             throw new ProtocolException("method does not support a request body: " + method);
         } else if (httpEngine.hasResponse()) {
             throw new ProtocolException("cannot write request body after response has been read");
         }

         return result;
     }

     @Override public final Permission getPermission() throws IOException {
         String connectToAddress = getConnectToHost() + ":" + getConnectToPort();
         return new SocketPermission(connectToAddress, "connect, resolve");
     }

     private String getConnectToHost() {
         return usingProxy()
                 ? ((InetSocketAddress) proxy.address()).getHostName()
                 : getURL().getHost();
     }

     private int getConnectToPort() {
         int hostPort = usingProxy()
                 ? ((InetSocketAddress) proxy.address()).getPort()
                 : getURL().getPort();
         return hostPort < 0 ? getDefaultPort() : hostPort;
     }

     @Override public final String getRequestProperty(String field) {
         if (field == null) {
             return null;
         }
         return rawRequestHeaders.get(field);
     }

     private void initHttpEngine() throws IOException {
         if (httpEngineFailure != null) {
             throw httpEngineFailure;
         } else if (httpEngine != null) {
             return;
         }

         connected = true;
         try {
             if (doOutput) {
                 if (method == HttpEngine.GET) {
                     // they are requesting a stream to write to. This implies a POST method
                     method = HttpEngine.POST;
                 } else if (method != HttpEngine.POST && method != HttpEngine.PUT) {
                     // If the request method is neither POST nor PUT, then you're not writing
                     throw new ProtocolException(method + " does not support writing");
                 }
             }
             httpEngine = newHttpEngine(method, rawRequestHeaders, null, null);
         } catch (IOException e) {
             httpEngineFailure = e;
             throw e;
         }
     }

     /**
      * Create a new HTTP engine. This hook method is non-final so it can be
      * overridden by HttpsURLConnectionImpl.
      */
     protected HttpEngine newHttpEngine(String method, RawHeaders requestHeaders,
             HttpConnection connection, RetryableOutputStream requestBody) throws IOException {
         return new HttpEngine(this, method, requestHeaders, connection, requestBody);
     }

     /**
      * Aggressively tries to get the final HTTP response, potentially making
      * many HTTP requests in the process in order to cope with redirects and
      * authentication.
      */
     private HttpEngine getResponse() throws IOException {
         initHttpEngine();

         if (httpEngine.hasResponse()) {
             return httpEngine;
         }

         while (true) {
             try {
                 httpEngine.sendRequest();
                 httpEngine.readResponse();
             } catch (IOException e) {
                 /*
                  * If the connection was recycled, its staleness may have caused
                  * the failure. Silently retry with a different connection.
                  */
                 OutputStream requestBody = httpEngine.getRequestBody();
                 if (httpEngine.hasRecycledConnection()
                         && (requestBody == null || requestBody instanceof RetryableOutputStream)) {
                     httpEngine.release(false);
                     httpEngine = newHttpEngine(method, rawRequestHeaders, null,
                             (RetryableOutputStream) requestBody);
                     continue;
                 }
                 httpEngineFailure = e;
                 throw e;
             }

             Retry retry = processResponseHeaders();
             if (retry == Retry.NONE) {
                 httpEngine.automaticallyReleaseConnectionToPool();
                 return httpEngine;
             }

             /*
              * The first request was insufficient. Prepare for another...
              */
             String retryMethod = method;
             OutputStream requestBody = httpEngine.getRequestBody();

             /*
              * Although RFC 2616 10.3.2 specifies that a HTTP_MOVED_PERM
              * redirect should keep the same method, Chrome, Firefox and the
              * RI all issue GETs when following any redirect.
              */
             int responseCode = getResponseCode();
             if (responseCode == HTTP_MULT_CHOICE || responseCode == HTTP_MOVED_PERM
                     || responseCode == HTTP_MOVED_TEMP || responseCode == HTTP_SEE_OTHER) {
                 retryMethod = HttpEngine.GET;
                 requestBody = null;
             }

             if (requestBody != null && !(requestBody instanceof RetryableOutputStream)) {
                 throw new HttpRetryException("Cannot retry streamed HTTP body",
                         httpEngine.getResponseCode());
             }

             if (retry == Retry.DIFFERENT_CONNECTION) {
                 httpEngine.automaticallyReleaseConnectionToPool();
             } else {
                 httpEngine.markConnectionAsRecycled();
             }

             httpEngine.release(true);

             httpEngine = newHttpEngine(retryMethod, rawRequestHeaders,
                     httpEngine.getConnection(), (RetryableOutputStream) requestBody);
         }
     }

     HttpEngine getHttpEngine() {
         return httpEngine;
     }

     enum Retry {
         NONE,
         SAME_CONNECTION,
         DIFFERENT_CONNECTION
     }

     /**
      * Returns the retry action to take for the current response headers. The
      * headers, proxy and target URL or this connection may be adjusted to
      * prepare for a follow up request.
      */
     private Retry processResponseHeaders() throws IOException {
         switch (getResponseCode()) {
         case HTTP_PROXY_AUTH:
             if (!usingProxy()) {
                 throw new IOException(
                         "Received HTTP_PROXY_AUTH (407) code while not using proxy");
             }
             // fall-through
         case HTTP_UNAUTHORIZED:
             boolean credentialsFound = processAuthHeader(getResponseCode(),
                     httpEngine.getResponseHeaders(), rawRequestHeaders);
             return credentialsFound ? Retry.SAME_CONNECTION : Retry.NONE;

         case HTTP_MULT_CHOICE:
         case HTTP_MOVED_PERM:
         case HTTP_MOVED_TEMP:
         case HTTP_SEE_OTHER:
             if (!getInstanceFollowRedirects()) {
                 return Retry.NONE;
             }
             if (++redirectionCount > HttpEngine.MAX_REDIRECTS) {
                 throw new ProtocolException("Too many redirects");
             }
             String location = getHeaderField("Location");
             if (location == null) {
                 return Retry.NONE;
             }
             URL previousUrl = url;
             url = new URL(previousUrl, location);
             if (!previousUrl.getProtocol().equals(url.getProtocol())) {
                 return Retry.NONE; // the scheme changed; don't retry.
             }
             if (previousUrl.getHost().equals(url.getHost())
                     && previousUrl.getEffectivePort() == url.getEffectivePort()) {
                 return Retry.SAME_CONNECTION;
             } else {
                 return Retry.DIFFERENT_CONNECTION;
             }

         default:
             return Retry.NONE;
         }
     }

     /**
      * React to a failed authorization response by looking up new credentials.
      *
      * @return true if credentials have been added to successorRequestHeaders
      *     and another request should be attempted.
      */
     final boolean processAuthHeader(int responseCode, ResponseHeaders response,
             RawHeaders successorRequestHeaders) throws IOException {
         if (responseCode != HTTP_PROXY_AUTH && responseCode != HTTP_UNAUTHORIZED) {
             throw new IllegalArgumentException("Bad response code: " + responseCode);
         }

         // keep asking for username/password until authorized
         String challengeHeader = responseCode == HTTP_PROXY_AUTH
                 ? "Proxy-Authenticate"
                 : "WWW-Authenticate";
         String credentials = getAuthorizationCredentials(response.getHeaders(), challengeHeader);
         if (credentials == null) {
             return false; // could not find credentials, end request cycle
         }

         // add authorization credentials, bypassing the already-connected check
         String fieldName = responseCode == HTTP_PROXY_AUTH
                 ? "Proxy-Authorization"
                 : "Authorization";
         successorRequestHeaders.set(fieldName, credentials);
         return true;
     }

     /**
      * Returns the authorization credentials on the base of provided challenge.
      */
     private String getAuthorizationCredentials(RawHeaders responseHeaders, String challengeHeader)
             throws IOException {
         List<Challenge> challenges = HeaderParser.parseChallenges(responseHeaders, challengeHeader);
         if (challenges.isEmpty()) {
             throw new IOException("No authentication challenges found");
         }

         for (Challenge challenge : challenges) {
             // use the global authenticator to get the password
             PasswordAuthentication auth = Authenticator.requestPasswordAuthentication(
                     getConnectToInetAddress(), getConnectToPort(), url.getProtocol(),
                     challenge.realm, challenge.scheme);
             if (auth == null) {
                 continue;
             }

             // base64 encode the username and password
             String usernameAndPassword = auth.getUserName() + ":" + new String(auth.getPassword());
             byte[] bytes = usernameAndPassword.getBytes(Charsets.ISO_8859_1);
             String encoded = Base64.encode(bytes);
             return challenge.scheme + " " + encoded;
         }

         return null;
     }

     private InetAddress getConnectToInetAddress() throws IOException {
         return usingProxy()
                 ? ((InetSocketAddress) proxy.address()).getAddress()
                 : InetAddress.getByName(getURL().getHost());
     }

     final int getDefaultPort() {
         return defaultPort;
     }

     /** @see HttpURLConnection#setFixedLengthStreamingMode(int) */
     final int getFixedContentLength() {
         return fixedContentLength;
     }

     /** @see HttpURLConnection#setChunkedStreamingMode(int) */
     final int getChunkLength() {
         return chunkLength;
     }

     final Proxy getProxy() {
         return proxy;
     }

     final void setProxy(Proxy proxy) {
         this.proxy = proxy;
     }

     @Override public final boolean usingProxy() {
         return (proxy != null && proxy.type() != Proxy.Type.DIRECT);
     }

     @Override public String getResponseMessage() throws IOException {
         return getResponse().getResponseHeaders().getHeaders().getResponseMessage();
     }

     @Override public final int getResponseCode() throws IOException {
         return getResponse().getResponseCode();
     }

     @Override public final void setRequestProperty(String field, String newValue) {
         if (connected) {
             throw new IllegalStateException("Cannot set request property after connection is made");
         }
         if (field == null) {
             throw new NullPointerException("field == null");
         }
         rawRequestHeaders.set(field, newValue);
     }

     @Override public final void addRequestProperty(String field, String value) {
         if (connected) {
             throw new IllegalStateException("Cannot add request property after connection is made");
         }
         if (field == null) {
             throw new NullPointerException("field == null");
         }
         rawRequestHeaders.add(field, value);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package libcore.net.http;

	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.net.Authenticator;
	import java.net.HttpRetryException;
	import java.net.HttpURLConnection;
	import java.net.InetAddress;
	import java.net.InetSocketAddress;
	import java.net.PasswordAuthentication;
	import java.net.ProtocolException;
	import java.net.Proxy;
	import java.net.SocketPermission;
	import java.net.URL;
	import java.nio.charset.Charsets;
	import java.security.Permission;
	import java.util.List;
	import java.util.Map;
	import libcore.io.Base64;
	import libcore.io.IoUtils;

	/**
	* This implementation uses HttpEngine to send requests and receive responses.
	* This class may use multiple HttpEngines to follow redirects, authentication
	* retries, etc. to retrieve the final response body.
	*
	* <h3>What does 'connected' mean?</h3>
	* This class inherits a {@code connected} field from the superclass. That field
	* is <strong>not</strong> used to indicate not whether this URLConnection is
	* currently connected. Instead, it indicates whether a connection has ever been
	* attempted. Once a connection has been attempted, certain properties (request
	* header fields, request method, etc.) are immutable. Test the {@code
	* connection} field on this class for null/non-null to determine of an instance
	* is currently connected to a server.
	*/
	class HttpURLConnectionImpl extends HttpURLConnection {

	private final int defaultPort;

	private Proxy proxy;

	private final RawHeaders rawRequestHeaders = new RawHeaders();

	private int redirectionCount;

	protected IOException httpEngineFailure;
	protected HttpEngine httpEngine;

	protected HttpURLConnectionImpl(URL url, int port) {
	super(url);
	defaultPort = port;
	}

	protected HttpURLConnectionImpl(URL url, int port, Proxy proxy) {
	this(url, port);
	this.proxy = proxy;
	}

	@Override public final void connect() throws IOException {
	initHttpEngine();
	try {
	httpEngine.sendRequest();
	} catch (IOException e) {
	httpEngineFailure = e;
	throw e;
	}
	}

	@Override public final void disconnect() {
	// Calling disconnect() before a connection exists should have no effect.
	if (httpEngine != null) {
	// We close the response body here instead of in
	// HttpEngine.release because that is called when input
	// has been completely read from the underlying socket.
	// However the response body can be a GZIPInputStream that
	// still has unread data.
	if (httpEngine.hasResponse()) {
	IoUtils.closeQuietly(httpEngine.getResponseBody());
	}
	httpEngine.release(false);
	}
	}

	/**
	* Returns an input stream from the server in the case of error such as the
	* requested file (txt, htm, html) is not found on the remote server.
	*/
	@Override public final InputStream getErrorStream() {
	try {
	HttpEngine response = getResponse();
	if (response.hasResponseBody()
	&& response.getResponseCode() >= HTTP_BAD_REQUEST) {
	return response.getResponseBody();
	}
	return null;
	} catch (IOException e) {
	return null;
	}
	}

	/**
	* Returns the value of the field at {@code position}. Returns null if there
	* are fewer than {@code position} headers.
	*/
	@Override public final String getHeaderField(int position) {
	try {
	return getResponse().getResponseHeaders().getHeaders().getValue(position);
	} catch (IOException e) {
	return null;
	}
	}

	/**
	* Returns the value of the field corresponding to the {@code fieldName}, or
	* null if there is no such field. If the field has multiple values, the
	* last value is returned.
	*/
	@Override public final String getHeaderField(String fieldName) {
	try {
	RawHeaders rawHeaders = getResponse().getResponseHeaders().getHeaders();
	return fieldName == null
	? rawHeaders.getStatusLine()
	: rawHeaders.get(fieldName);
	} catch (IOException e) {
	return null;
	}
	}

	@Override public final String getHeaderFieldKey(int position) {
	try {
	return getResponse().getResponseHeaders().getHeaders().getFieldName(position);
	} catch (IOException e) {
	return null;
	}
	}

	@Override public final Map<String, List<String>> getHeaderFields() {
	try {
	return getResponse().getResponseHeaders().getHeaders().toMultimap();
	} catch (IOException e) {
	return null;
	}
	}

	@Override public final Map<String, List<String>> getRequestProperties() {
	if (connected) {
	throw new IllegalStateException(
	"Cannot access request header fields after connection is set");
	}
	return rawRequestHeaders.toMultimap();
	}

	@Override public final InputStream getInputStream() throws IOException {
	if (!doInput) {
	throw new ProtocolException("This protocol does not support input");
	}

	HttpEngine response = getResponse();

	/*
	* if the requested file does not exist, throw an exception formerly the
	* Error page from the server was returned if the requested file was
	* text/html this has changed to return FileNotFoundException for all
	* file types
	*/
	if (getResponseCode() >= HTTP_BAD_REQUEST) {
	throw new FileNotFoundException(url.toString());
	}

	InputStream result = response.getResponseBody();
	if (result == null) {
	throw new IOException("No response body exists; responseCode=" + getResponseCode());
	}
	return result;
	}

	@Override public final OutputStream getOutputStream() throws IOException {
	connect();

	OutputStream result = httpEngine.getRequestBody();
	if (result == null) {
	throw new ProtocolException("method does not support a request body: " + method);
	} else if (httpEngine.hasResponse()) {
	throw new ProtocolException("cannot write request body after response has been read");
	}

	return result;
	}

	@Override public final Permission getPermission() throws IOException {
	String connectToAddress = getConnectToHost() + ":" + getConnectToPort();
	return new SocketPermission(connectToAddress, "connect, resolve");
	}

	private String getConnectToHost() {
	return usingProxy()
	? ((InetSocketAddress) proxy.address()).getHostName()
	: getURL().getHost();
	}

	private int getConnectToPort() {
	int hostPort = usingProxy()
	? ((InetSocketAddress) proxy.address()).getPort()
	: getURL().getPort();
	return hostPort < 0 ? getDefaultPort() : hostPort;
	}

	@Override public final String getRequestProperty(String field) {
	if (field == null) {
	return null;
	}
	return rawRequestHeaders.get(field);
	}

	private void initHttpEngine() throws IOException {
	if (httpEngineFailure != null) {
	throw httpEngineFailure;
	} else if (httpEngine != null) {
	return;
	}

	connected = true;
	try {
	if (doOutput) {
	if (method == HttpEngine.GET) {
	// they are requesting a stream to write to. This implies a POST method
	method = HttpEngine.POST;
	} else if (method != HttpEngine.POST && method != HttpEngine.PUT) {
	// If the request method is neither POST nor PUT, then you're not writing
	throw new ProtocolException(method + " does not support writing");
	}
	}
	httpEngine = newHttpEngine(method, rawRequestHeaders, null, null);
	} catch (IOException e) {
	httpEngineFailure = e;
	throw e;
	}
	}

	/**
	* Create a new HTTP engine. This hook method is non-final so it can be
	* overridden by HttpsURLConnectionImpl.
	*/
	protected HttpEngine newHttpEngine(String method, RawHeaders requestHeaders,
	HttpConnection connection, RetryableOutputStream requestBody) throws IOException {
	return new HttpEngine(this, method, requestHeaders, connection, requestBody);
	}

	/**
	* Aggressively tries to get the final HTTP response, potentially making
	* many HTTP requests in the process in order to cope with redirects and
	* authentication.
	*/
	private HttpEngine getResponse() throws IOException {
	initHttpEngine();

	if (httpEngine.hasResponse()) {
	return httpEngine;
	}

	while (true) {
	try {
	httpEngine.sendRequest();
	httpEngine.readResponse();
	} catch (IOException e) {
	/*
	* If the connection was recycled, its staleness may have caused
	* the failure. Silently retry with a different connection.
	*/
	OutputStream requestBody = httpEngine.getRequestBody();
	if (httpEngine.hasRecycledConnection()
	&& (requestBody == null \|\| requestBody instanceof RetryableOutputStream)) {
	httpEngine.release(false);
	httpEngine = newHttpEngine(method, rawRequestHeaders, null,
	(RetryableOutputStream) requestBody);
	continue;
	}
	httpEngineFailure = e;
	throw e;
	}

	Retry retry = processResponseHeaders();
	if (retry == Retry.NONE) {
	httpEngine.automaticallyReleaseConnectionToPool();
	return httpEngine;
	}

	/*
	* The first request was insufficient. Prepare for another...
	*/
	String retryMethod = method;
	OutputStream requestBody = httpEngine.getRequestBody();

	/*
	* Although RFC 2616 10.3.2 specifies that a HTTP_MOVED_PERM
	* redirect should keep the same method, Chrome, Firefox and the
	* RI all issue GETs when following any redirect.
	*/
	int responseCode = getResponseCode();
	if (responseCode == HTTP_MULT_CHOICE \|\| responseCode == HTTP_MOVED_PERM
	\|\| responseCode == HTTP_MOVED_TEMP \|\| responseCode == HTTP_SEE_OTHER) {
	retryMethod = HttpEngine.GET;
	requestBody = null;
	}

	if (requestBody != null && !(requestBody instanceof RetryableOutputStream)) {
	throw new HttpRetryException("Cannot retry streamed HTTP body",
	httpEngine.getResponseCode());
	}

	if (retry == Retry.DIFFERENT_CONNECTION) {
	httpEngine.automaticallyReleaseConnectionToPool();
	} else {
	httpEngine.markConnectionAsRecycled();
	}

	httpEngine.release(true);

	httpEngine = newHttpEngine(retryMethod, rawRequestHeaders,
	httpEngine.getConnection(), (RetryableOutputStream) requestBody);
	}
	}

	HttpEngine getHttpEngine() {
	return httpEngine;
	}

	enum Retry {
	NONE,
	SAME_CONNECTION,
	DIFFERENT_CONNECTION
	}

	/**
	* Returns the retry action to take for the current response headers. The
	* headers, proxy and target URL or this connection may be adjusted to
	* prepare for a follow up request.
	*/
	private Retry processResponseHeaders() throws IOException {
	switch (getResponseCode()) {
	case HTTP_PROXY_AUTH:
	if (!usingProxy()) {
	throw new IOException(
	"Received HTTP_PROXY_AUTH (407) code while not using proxy");
	}
	// fall-through
	case HTTP_UNAUTHORIZED:
	boolean credentialsFound = processAuthHeader(getResponseCode(),
	httpEngine.getResponseHeaders(), rawRequestHeaders);
	return credentialsFound ? Retry.SAME_CONNECTION : Retry.NONE;

	case HTTP_MULT_CHOICE:
	case HTTP_MOVED_PERM:
	case HTTP_MOVED_TEMP:
	case HTTP_SEE_OTHER:
	if (!getInstanceFollowRedirects()) {
	return Retry.NONE;
	}
	if (++redirectionCount > HttpEngine.MAX_REDIRECTS) {
	throw new ProtocolException("Too many redirects");
	}
	String location = getHeaderField("Location");
	if (location == null) {
	return Retry.NONE;
	}
	URL previousUrl = url;
	url = new URL(previousUrl, location);
	if (!previousUrl.getProtocol().equals(url.getProtocol())) {
	return Retry.NONE; // the scheme changed; don't retry.
	}
	if (previousUrl.getHost().equals(url.getHost())
	&& previousUrl.getEffectivePort() == url.getEffectivePort()) {
	return Retry.SAME_CONNECTION;
	} else {
	return Retry.DIFFERENT_CONNECTION;
	}

	default:
	return Retry.NONE;
	}
	}

	/**
	* React to a failed authorization response by looking up new credentials.
	*
	* @return true if credentials have been added to successorRequestHeaders
	* and another request should be attempted.
	*/
	final boolean processAuthHeader(int responseCode, ResponseHeaders response,
	RawHeaders successorRequestHeaders) throws IOException {
	if (responseCode != HTTP_PROXY_AUTH && responseCode != HTTP_UNAUTHORIZED) {
	throw new IllegalArgumentException("Bad response code: " + responseCode);
	}

	// keep asking for username/password until authorized
	String challengeHeader = responseCode == HTTP_PROXY_AUTH
	? "Proxy-Authenticate"
	: "WWW-Authenticate";
	String credentials = getAuthorizationCredentials(response.getHeaders(), challengeHeader);
	if (credentials == null) {
	return false; // could not find credentials, end request cycle
	}

	// add authorization credentials, bypassing the already-connected check
	String fieldName = responseCode == HTTP_PROXY_AUTH
	? "Proxy-Authorization"
	: "Authorization";
	successorRequestHeaders.set(fieldName, credentials);
	return true;
	}

	/**
	* Returns the authorization credentials on the base of provided challenge.
	*/
	private String getAuthorizationCredentials(RawHeaders responseHeaders, String challengeHeader)
	throws IOException {
	List<Challenge> challenges = HeaderParser.parseChallenges(responseHeaders, challengeHeader);
	if (challenges.isEmpty()) {
	throw new IOException("No authentication challenges found");
	}

	for (Challenge challenge : challenges) {
	// use the global authenticator to get the password
	PasswordAuthentication auth = Authenticator.requestPasswordAuthentication(
	getConnectToInetAddress(), getConnectToPort(), url.getProtocol(),
	challenge.realm, challenge.scheme);
	if (auth == null) {
	continue;
	}

	// base64 encode the username and password
	String usernameAndPassword = auth.getUserName() + ":" + new String(auth.getPassword());
	byte[] bytes = usernameAndPassword.getBytes(Charsets.ISO_8859_1);
	String encoded = Base64.encode(bytes);
	return challenge.scheme + " " + encoded;
	}

	return null;
	}

	private InetAddress getConnectToInetAddress() throws IOException {
	return usingProxy()
	? ((InetSocketAddress) proxy.address()).getAddress()
	: InetAddress.getByName(getURL().getHost());
	}

	final int getDefaultPort() {
	return defaultPort;
	}

	/** @see HttpURLConnection#setFixedLengthStreamingMode(int) */
	final int getFixedContentLength() {
	return fixedContentLength;
	}

	/** @see HttpURLConnection#setChunkedStreamingMode(int) */
	final int getChunkLength() {
	return chunkLength;
	}

	final Proxy getProxy() {
	return proxy;
	}

	final void setProxy(Proxy proxy) {
	this.proxy = proxy;
	}

	@Override public final boolean usingProxy() {
	return (proxy != null && proxy.type() != Proxy.Type.DIRECT);
	}

	@Override public String getResponseMessage() throws IOException {
	return getResponse().getResponseHeaders().getHeaders().getResponseMessage();
	}

	@Override public final int getResponseCode() throws IOException {
	return getResponse().getResponseCode();
	}

	@Override public final void setRequestProperty(String field, String newValue) {
	if (connected) {
	throw new IllegalStateException("Cannot set request property after connection is made");
	}
	if (field == null) {
	throw new NullPointerException("field == null");
	}
	rawRequestHeaders.set(field, newValue);
	}

	@Override public final void addRequestProperty(String field, String value) {
	if (connected) {
	throw new IllegalStateException("Cannot add request property after connection is made");
	}
	if (field == null) {
	throw new NullPointerException("field == null");
	}
	rawRequestHeaders.add(field, value);
	}
	}