The Tor Browser: mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/client/DefaultRequestDirector.java@fc2d59ddac77 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/client/DefaultRequestDirector.java@fc2d59ddac77 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/client/DefaultRequestDirector.java

Wed, 31 Dec 2014 07:22:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:22:50 +0100
branch: TOR_BUG_3246
changeset 4: fc2d59ddac77
permissions: -rw-r--r--

Correct previous dual key logic pending first delivery installment.

 /*
  * ====================================================================
  * 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.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  *
  */
 package ch.boye.httpclientandroidlib.impl.client;
 import java.io.IOException;
 import java.io.InterruptedIOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import ch.boye.httpclientandroidlib.annotation.NotThreadSafe;
 import ch.boye.httpclientandroidlib.androidextra.HttpClientAndroidLog;
 /* LogFactory removed by HttpClient for Android script. */
 import ch.boye.httpclientandroidlib.ConnectionReuseStrategy;
 import ch.boye.httpclientandroidlib.Header;
 import ch.boye.httpclientandroidlib.HttpEntity;
 import ch.boye.httpclientandroidlib.HttpEntityEnclosingRequest;
 import ch.boye.httpclientandroidlib.HttpException;
 import ch.boye.httpclientandroidlib.HttpHost;
 import ch.boye.httpclientandroidlib.HttpRequest;
 import ch.boye.httpclientandroidlib.HttpResponse;
 import ch.boye.httpclientandroidlib.ProtocolException;
 import ch.boye.httpclientandroidlib.ProtocolVersion;
 import ch.boye.httpclientandroidlib.auth.AuthScheme;
 import ch.boye.httpclientandroidlib.auth.AuthScope;
 import ch.boye.httpclientandroidlib.auth.AuthState;
 import ch.boye.httpclientandroidlib.auth.AuthenticationException;
 import ch.boye.httpclientandroidlib.auth.Credentials;
 import ch.boye.httpclientandroidlib.auth.MalformedChallengeException;
 import ch.boye.httpclientandroidlib.client.AuthenticationHandler;
 import ch.boye.httpclientandroidlib.client.RedirectStrategy;
 import ch.boye.httpclientandroidlib.client.RequestDirector;
 import ch.boye.httpclientandroidlib.client.CredentialsProvider;
 import ch.boye.httpclientandroidlib.client.HttpRequestRetryHandler;
 import ch.boye.httpclientandroidlib.client.NonRepeatableRequestException;
 import ch.boye.httpclientandroidlib.client.RedirectException;
 import ch.boye.httpclientandroidlib.client.UserTokenHandler;
 import ch.boye.httpclientandroidlib.client.methods.AbortableHttpRequest;
 import ch.boye.httpclientandroidlib.client.methods.HttpUriRequest;
 import ch.boye.httpclientandroidlib.client.params.ClientPNames;
 import ch.boye.httpclientandroidlib.client.params.HttpClientParams;
 import ch.boye.httpclientandroidlib.client.protocol.ClientContext;
 import ch.boye.httpclientandroidlib.client.utils.URIUtils;
 import ch.boye.httpclientandroidlib.conn.BasicManagedEntity;
 import ch.boye.httpclientandroidlib.conn.ClientConnectionManager;
 import ch.boye.httpclientandroidlib.conn.ClientConnectionRequest;
 import ch.boye.httpclientandroidlib.conn.ConnectionKeepAliveStrategy;
 import ch.boye.httpclientandroidlib.conn.ManagedClientConnection;
 import ch.boye.httpclientandroidlib.conn.params.ConnManagerParams;
 import ch.boye.httpclientandroidlib.conn.routing.BasicRouteDirector;
 import ch.boye.httpclientandroidlib.conn.routing.HttpRoute;
 import ch.boye.httpclientandroidlib.conn.routing.HttpRouteDirector;
 import ch.boye.httpclientandroidlib.conn.routing.HttpRoutePlanner;
 import ch.boye.httpclientandroidlib.conn.scheme.Scheme;
 import ch.boye.httpclientandroidlib.entity.BufferedHttpEntity;
 import ch.boye.httpclientandroidlib.impl.conn.ConnectionShutdownException;
 import ch.boye.httpclientandroidlib.message.BasicHttpRequest;
 import ch.boye.httpclientandroidlib.params.HttpConnectionParams;
 import ch.boye.httpclientandroidlib.params.HttpParams;
 import ch.boye.httpclientandroidlib.params.HttpProtocolParams;
 import ch.boye.httpclientandroidlib.protocol.ExecutionContext;
 import ch.boye.httpclientandroidlib.protocol.HttpContext;
 import ch.boye.httpclientandroidlib.protocol.HttpProcessor;
 import ch.boye.httpclientandroidlib.protocol.HttpRequestExecutor;
 import ch.boye.httpclientandroidlib.util.EntityUtils;
 /**
  * Default implementation of {@link RequestDirector}.
  * <p>
  * The following parameters can be used to customize the behavior of this
  * class:
  * <ul>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#PROTOCOL_VERSION}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#STRICT_TRANSFER_ENCODING}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#HTTP_ELEMENT_CHARSET}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#USE_EXPECT_CONTINUE}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#WAIT_FOR_CONTINUE}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreProtocolPNames#USER_AGENT}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#SOCKET_BUFFER_SIZE}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#MAX_LINE_LENGTH}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#MAX_HEADER_COUNT}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#SO_TIMEOUT}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#SO_LINGER}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#SO_REUSEADDR}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#TCP_NODELAY}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#CONNECTION_TIMEOUT}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.params.CoreConnectionPNames#STALE_CONNECTION_CHECK}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.conn.params.ConnRoutePNames#FORCED_ROUTE}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.conn.params.ConnRoutePNames#LOCAL_ADDRESS}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.conn.params.ConnRoutePNames#DEFAULT_PROXY}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.cookie.params.CookieSpecPNames#DATE_PATTERNS}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.cookie.params.CookieSpecPNames#SINGLE_COOKIE_HEADER}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.auth.params.AuthPNames#CREDENTIAL_CHARSET}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#COOKIE_POLICY}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#HANDLE_AUTHENTICATION}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#HANDLE_REDIRECTS}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#MAX_REDIRECTS}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#ALLOW_CIRCULAR_REDIRECTS}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#VIRTUAL_HOST}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#DEFAULT_HOST}</li>
  *  <li>{@link ch.boye.httpclientandroidlib.client.params.ClientPNames#DEFAULT_HEADERS}</li>
  * </ul>
  *
  * @since 4.0
  */
 @SuppressWarnings("deprecation")
 @NotThreadSafe // e.g. managedConn
 public class DefaultRequestDirector implements RequestDirector {
     public HttpClientAndroidLog log;
     /** The connection manager. */
     protected final ClientConnectionManager connManager;
     /** The route planner. */
     protected final HttpRoutePlanner routePlanner;
     /** The connection re-use strategy. */
     protected final ConnectionReuseStrategy reuseStrategy;
     /** The keep-alive duration strategy. */
     protected final ConnectionKeepAliveStrategy keepAliveStrategy;
     /** The request executor. */
     protected final HttpRequestExecutor requestExec;
     /** The HTTP protocol processor. */
     protected final HttpProcessor httpProcessor;
     /** The request retry handler. */
     protected final HttpRequestRetryHandler retryHandler;
     /** The redirect handler. */
     @Deprecated
     protected final ch.boye.httpclientandroidlib.client.RedirectHandler redirectHandler = null;
     /** The redirect strategy. */
     protected final RedirectStrategy redirectStrategy;
     /** The target authentication handler. */
     protected final AuthenticationHandler targetAuthHandler;
     /** The proxy authentication handler. */
     protected final AuthenticationHandler proxyAuthHandler;
     /** The user token handler. */
     protected final UserTokenHandler userTokenHandler;
     /** The HTTP parameters. */
     protected final HttpParams params;
     /** The currently allocated connection. */
     protected ManagedClientConnection managedConn;
     protected final AuthState targetAuthState;
     protected final AuthState proxyAuthState;
     private int execCount;
     private int redirectCount;
     private int maxRedirects;
     private HttpHost virtualHost;
     @Deprecated
     public DefaultRequestDirector(
             final HttpRequestExecutor requestExec,
             final ClientConnectionManager conman,
             final ConnectionReuseStrategy reustrat,
             final ConnectionKeepAliveStrategy kastrat,
             final HttpRoutePlanner rouplan,
             final HttpProcessor httpProcessor,
             final HttpRequestRetryHandler retryHandler,
             final ch.boye.httpclientandroidlib.client.RedirectHandler redirectHandler,
             final AuthenticationHandler targetAuthHandler,
             final AuthenticationHandler proxyAuthHandler,
             final UserTokenHandler userTokenHandler,
             final HttpParams params) {
         this(new HttpClientAndroidLog(DefaultRequestDirector.class),
                 requestExec, conman, reustrat, kastrat, rouplan, httpProcessor, retryHandler,
                 new DefaultRedirectStrategyAdaptor(redirectHandler),
                 targetAuthHandler, proxyAuthHandler, userTokenHandler, params);
     }
     /**
      * @since 4.1
      */
     public DefaultRequestDirector(
             final HttpClientAndroidLog log,
             final HttpRequestExecutor requestExec,
             final ClientConnectionManager conman,
             final ConnectionReuseStrategy reustrat,
             final ConnectionKeepAliveStrategy kastrat,
             final HttpRoutePlanner rouplan,
             final HttpProcessor httpProcessor,
             final HttpRequestRetryHandler retryHandler,
             final RedirectStrategy redirectStrategy,
             final AuthenticationHandler targetAuthHandler,
             final AuthenticationHandler proxyAuthHandler,
             final UserTokenHandler userTokenHandler,
             final HttpParams params) {
         if (log == null) {
             throw new IllegalArgumentException
                 ("Log may not be null.");
         }
         if (requestExec == null) {
             throw new IllegalArgumentException
                 ("Request executor may not be null.");
         }
         if (conman == null) {
             throw new IllegalArgumentException
                 ("Client connection manager may not be null.");
         }
         if (reustrat == null) {
             throw new IllegalArgumentException
                 ("Connection reuse strategy may not be null.");
         }
         if (kastrat == null) {
             throw new IllegalArgumentException
                 ("Connection keep alive strategy may not be null.");
         }
         if (rouplan == null) {
             throw new IllegalArgumentException
                 ("Route planner may not be null.");
         }
         if (httpProcessor == null) {
             throw new IllegalArgumentException
                 ("HTTP protocol processor may not be null.");
         }
         if (retryHandler == null) {
             throw new IllegalArgumentException
                 ("HTTP request retry handler may not be null.");
         }
         if (redirectStrategy == null) {
             throw new IllegalArgumentException
                 ("Redirect strategy may not be null.");
         }
         if (targetAuthHandler == null) {
             throw new IllegalArgumentException
                 ("Target authentication handler may not be null.");
         }
         if (proxyAuthHandler == null) {
             throw new IllegalArgumentException
                 ("Proxy authentication handler may not be null.");
         }
         if (userTokenHandler == null) {
             throw new IllegalArgumentException
                 ("User token handler may not be null.");
         }
         if (params == null) {
             throw new IllegalArgumentException
                 ("HTTP parameters may not be null");
         }
         this.log               = log;
         this.requestExec       = requestExec;
         this.connManager       = conman;
         this.reuseStrategy     = reustrat;
         this.keepAliveStrategy = kastrat;
         this.routePlanner      = rouplan;
         this.httpProcessor     = httpProcessor;
         this.retryHandler      = retryHandler;
         this.redirectStrategy  = redirectStrategy;
         this.targetAuthHandler = targetAuthHandler;
         this.proxyAuthHandler  = proxyAuthHandler;
         this.userTokenHandler  = userTokenHandler;
         this.params            = params;
         this.managedConn       = null;
         this.execCount = 0;
         this.redirectCount = 0;
         this.maxRedirects = this.params.getIntParameter(ClientPNames.MAX_REDIRECTS, 100);
         this.targetAuthState = new AuthState();
         this.proxyAuthState = new AuthState();
     } // constructor
     private RequestWrapper wrapRequest(
             final HttpRequest request) throws ProtocolException {
         if (request instanceof HttpEntityEnclosingRequest) {
             return new EntityEnclosingRequestWrapper(
                     (HttpEntityEnclosingRequest) request);
         } else {
             return new RequestWrapper(
                     request);
         }
     }
     protected void rewriteRequestURI(
             final RequestWrapper request,
             final HttpRoute route) throws ProtocolException {
         try {
             URI uri = request.getURI();
             if (route.getProxyHost() != null && !route.isTunnelled()) {
                 // Make sure the request URI is absolute
                 if (!uri.isAbsolute()) {
                     HttpHost target = route.getTargetHost();
                     uri = URIUtils.rewriteURI(uri, target);
                     request.setURI(uri);
                 }
             } else {
                 // Make sure the request URI is relative
                 if (uri.isAbsolute()) {
                     uri = URIUtils.rewriteURI(uri, null);
                     request.setURI(uri);
                 }
             }
         } catch (URISyntaxException ex) {
             throw new ProtocolException("Invalid URI: " +
                     request.getRequestLine().getUri(), ex);
         }
     }
     // non-javadoc, see interface ClientRequestDirector
     public HttpResponse execute(HttpHost target, HttpRequest request,
                                 HttpContext context)
         throws HttpException, IOException {
         HttpRequest orig = request;
         RequestWrapper origWrapper = wrapRequest(orig);
         origWrapper.setParams(params);
         HttpRoute origRoute = determineRoute(target, origWrapper, context);
         virtualHost = (HttpHost) orig.getParams().getParameter(
                 ClientPNames.VIRTUAL_HOST);
         // HTTPCLIENT-1092 - add the port if necessary
         if (virtualHost != null && virtualHost.getPort() == -1)
         {
             int port = target.getPort();
             if (port != -1){
                 virtualHost = new HttpHost(virtualHost.getHostName(), port, virtualHost.getSchemeName());
             }
         }
         RoutedRequest roureq = new RoutedRequest(origWrapper, origRoute);
         boolean reuse = false;
         boolean done = false;
         try {
             HttpResponse response = null;
             while (!done) {
                 // In this loop, the RoutedRequest may be replaced by a
                 // followup request and route. The request and route passed
                 // in the method arguments will be replaced. The original
                 // request is still available in 'orig'.
                 RequestWrapper wrapper = roureq.getRequest();
                 HttpRoute route = roureq.getRoute();
                 response = null;
                 // See if we have a user token bound to the execution context
                 Object userToken = context.getAttribute(ClientContext.USER_TOKEN);
                 // Allocate connection if needed
                 if (managedConn == null) {
                     ClientConnectionRequest connRequest = connManager.requestConnection(
                             route, userToken);
                     if (orig instanceof AbortableHttpRequest) {
                         ((AbortableHttpRequest) orig).setConnectionRequest(connRequest);
                     }
                     long timeout = ConnManagerParams.getTimeout(params);
                     try {
                         managedConn = connRequest.getConnection(timeout, TimeUnit.MILLISECONDS);
                     } catch(InterruptedException interrupted) {
                         InterruptedIOException iox = new InterruptedIOException();
                         iox.initCause(interrupted);
                         throw iox;
                     }
                     if (HttpConnectionParams.isStaleCheckingEnabled(params)) {
                         // validate connection
                         if (managedConn.isOpen()) {
                             this.log.debug("Stale connection check");
                             if (managedConn.isStale()) {
                                 this.log.debug("Stale connection detected");
                                 managedConn.close();
                             }
                         }
                     }
                 }
                 if (orig instanceof AbortableHttpRequest) {
                     ((AbortableHttpRequest) orig).setReleaseTrigger(managedConn);
                 }
                 try {
                     tryConnect(roureq, context);
                 } catch (TunnelRefusedException ex) {
                     if (this.log.isDebugEnabled()) {
                         this.log.debug(ex.getMessage());
                     }
                     response = ex.getResponse();
                     break;
                 }
                 // Reset headers on the request wrapper
                 wrapper.resetHeaders();
                 // Re-write request URI if needed
                 rewriteRequestURI(wrapper, route);
                 // Use virtual host if set
                 target = virtualHost;
                 if (target == null) {
                     target = route.getTargetHost();
                 }
                 HttpHost proxy = route.getProxyHost();
                 // Populate the execution context
                 context.setAttribute(ExecutionContext.HTTP_TARGET_HOST,
                         target);
                 context.setAttribute(ExecutionContext.HTTP_PROXY_HOST,
                         proxy);
                 context.setAttribute(ExecutionContext.HTTP_CONNECTION,
                         managedConn);
                 context.setAttribute(ClientContext.TARGET_AUTH_STATE,
                         targetAuthState);
                 context.setAttribute(ClientContext.PROXY_AUTH_STATE,
                         proxyAuthState);
                 // Run request protocol interceptors
                 requestExec.preProcess(wrapper, httpProcessor, context);
                 response = tryExecute(roureq, context);
                 if (response == null) {
                     // Need to start over
                     continue;
                 }
                 // Run response protocol interceptors
                 response.setParams(params);
                 requestExec.postProcess(response, httpProcessor, context);
                 // The connection is in or can be brought to a re-usable state.
                 reuse = reuseStrategy.keepAlive(response, context);
                 if (reuse) {
                     // Set the idle duration of this connection
                     long duration = keepAliveStrategy.getKeepAliveDuration(response, context);
                     if (this.log.isDebugEnabled()) {
                         String s;
                         if (duration > 0) {
                             s = "for " + duration + " " + TimeUnit.MILLISECONDS;
                         } else {
                             s = "indefinitely";
                         }
                         this.log.debug("Connection can be kept alive " + s);
                     }
                     managedConn.setIdleDuration(duration, TimeUnit.MILLISECONDS);
                 }
                 RoutedRequest followup = handleResponse(roureq, response, context);
                 if (followup == null) {
                     done = true;
                 } else {
                     if (reuse) {
                         // Make sure the response body is fully consumed, if present
                         HttpEntity entity = response.getEntity();
                         EntityUtils.consume(entity);
                         // entity consumed above is not an auto-release entity,
                         // need to mark the connection re-usable explicitly
                         managedConn.markReusable();
                     } else {
                         managedConn.close();
                         invalidateAuthIfSuccessful(this.proxyAuthState);
                         invalidateAuthIfSuccessful(this.targetAuthState);
                     }
                     // check if we can use the same connection for the followup
                     if (!followup.getRoute().equals(roureq.getRoute())) {
                         releaseConnection();
                     }
                     roureq = followup;
                 }
                 if (managedConn != null && userToken == null) {
                     userToken = userTokenHandler.getUserToken(context);
                     context.setAttribute(ClientContext.USER_TOKEN, userToken);
                     if (userToken != null) {
                         managedConn.setState(userToken);
                     }
                 }
             } // while not done
             // check for entity, release connection if possible
             if ((response == null) || (response.getEntity() == null) ||
                 !response.getEntity().isStreaming()) {
                 // connection not needed and (assumed to be) in re-usable state
                 if (reuse)
                     managedConn.markReusable();
                 releaseConnection();
             } else {
                 // install an auto-release entity
                 HttpEntity entity = response.getEntity();
                 entity = new BasicManagedEntity(entity, managedConn, reuse);
                 response.setEntity(entity);
             }
             return response;
         } catch (ConnectionShutdownException ex) {
             InterruptedIOException ioex = new InterruptedIOException(
                     "Connection has been shut down");
             ioex.initCause(ex);
             throw ioex;
         } catch (HttpException ex) {
             abortConnection();
             throw ex;
         } catch (IOException ex) {
             abortConnection();
             throw ex;
         } catch (RuntimeException ex) {
             abortConnection();
             throw ex;
         }
     } // execute
     /**
      * Establish connection either directly or through a tunnel and retry in case of
      * a recoverable I/O failure
      */
     private void tryConnect(
             final RoutedRequest req, final HttpContext context) throws HttpException, IOException {
         HttpRoute route = req.getRoute();
         int connectCount = 0;
         for (;;) {
             // Increment connect count
             connectCount++;
             try {
                 if (!managedConn.isOpen()) {
                     managedConn.open(route, context, params);
                 } else {
                     managedConn.setSocketTimeout(HttpConnectionParams.getSoTimeout(params));
                 }
                 establishRoute(route, context);
                 break;
             } catch (IOException ex) {
                 try {
                     managedConn.close();
                 } catch (IOException ignore) {
                 }
                 if (retryHandler.retryRequest(ex, connectCount, context)) {
                     if (this.log.isInfoEnabled()) {
                         this.log.info("I/O exception ("+ ex.getClass().getName() +
                                 ") caught when connecting to the target host: "
                                 + ex.getMessage());
                     }
                     if (this.log.isDebugEnabled()) {
                         this.log.debug(ex.getMessage(), ex);
                     }
                     this.log.info("Retrying connect");
                 } else {
                     throw ex;
                 }
             }
         }
     }
     /**
      * Execute request and retry in case of a recoverable I/O failure
      */
     private HttpResponse tryExecute(
             final RoutedRequest req, final HttpContext context) throws HttpException, IOException {
         RequestWrapper wrapper = req.getRequest();
         HttpRoute route = req.getRoute();
         HttpResponse response = null;
         Exception retryReason = null;
         for (;;) {
             // Increment total exec count (with redirects)
             execCount++;
             // Increment exec count for this particular request
             wrapper.incrementExecCount();
             if (!wrapper.isRepeatable()) {
                 this.log.debug("Cannot retry non-repeatable request");
                 if (retryReason != null) {
                     throw new NonRepeatableRequestException("Cannot retry request " +
                         "with a non-repeatable request entity.  The cause lists the " +
                         "reason the original request failed.", retryReason);
                 } else {
                     throw new NonRepeatableRequestException("Cannot retry request " +
                             "with a non-repeatable request entity.");
                 }
             }
             try {
                 if (!managedConn.isOpen()) {
                     // If we have a direct route to the target host
                     // just re-open connection and re-try the request
                     if (!route.isTunnelled()) {
                         this.log.debug("Reopening the direct connection.");
                         managedConn.open(route, context, params);
                     } else {
                         // otherwise give up
                         this.log.debug("Proxied connection. Need to start over.");
                         break;
                     }
                 }
                 if (this.log.isDebugEnabled()) {
                     this.log.debug("Attempt " + execCount + " to execute request");
                 }
                 response = requestExec.execute(wrapper, managedConn, context);
                 break;
             } catch (IOException ex) {
                 this.log.debug("Closing the connection.");
                 try {
                     managedConn.close();
                 } catch (IOException ignore) {
                 }
                 if (retryHandler.retryRequest(ex, wrapper.getExecCount(), context)) {
                     if (this.log.isInfoEnabled()) {
                         this.log.info("I/O exception ("+ ex.getClass().getName() +
                                 ") caught when processing request: "
                                 + ex.getMessage());
                     }
                     if (this.log.isDebugEnabled()) {
                         this.log.debug(ex.getMessage(), ex);
                     }
                     this.log.info("Retrying request");
                     retryReason = ex;
                 } else {
                     throw ex;
                 }
             }
         }
         return response;
     }
     /**
      * Returns the connection back to the connection manager
      * and prepares for retrieving a new connection during
      * the next request.
      */
     protected void releaseConnection() {
         // Release the connection through the ManagedConnection instead of the
         // ConnectionManager directly.  This lets the connection control how
         // it is released.
         try {
             managedConn.releaseConnection();
         } catch(IOException ignored) {
             this.log.debug("IOException releasing connection", ignored);
         }
         managedConn = null;
     }
     /**
      * Determines the route for a request.
      * Called by {@link #execute}
      * to determine the route for either the original or a followup request.
      *
      * @param target    the target host for the request.
      *                  Implementations may accept <code>null</code>
      *                  if they can still determine a route, for example
      *                  to a default target or by inspecting the request.
      * @param request   the request to execute
      * @param context   the context to use for the execution,
      *                  never <code>null</code>
      *
      * @return  the route the request should take
      *
      * @throws HttpException    in case of a problem
      */
     protected HttpRoute determineRoute(HttpHost    target,
                                            HttpRequest request,
                                            HttpContext context)
         throws HttpException {
         if (target == null) {
             target = (HttpHost) request.getParams().getParameter(
                 ClientPNames.DEFAULT_HOST);
         }
         if (target == null) {
             throw new IllegalStateException
                 ("Target host must not be null, or set in parameters.");
         }
         return this.routePlanner.determineRoute(target, request, context);
     }
     /**
      * Establishes the target route.
      *
      * @param route     the route to establish
      * @param context   the context for the request execution
      *
      * @throws HttpException    in case of a problem
      * @throws IOException      in case of an IO problem
      */
     protected void establishRoute(HttpRoute route, HttpContext context)
         throws HttpException, IOException {
         HttpRouteDirector rowdy = new BasicRouteDirector();
         int step;
         do {
             HttpRoute fact = managedConn.getRoute();
             step = rowdy.nextStep(route, fact);
             switch (step) {
             case HttpRouteDirector.CONNECT_TARGET:
             case HttpRouteDirector.CONNECT_PROXY:
                 managedConn.open(route, context, this.params);
                 break;
             case HttpRouteDirector.TUNNEL_TARGET: {
                 boolean secure = createTunnelToTarget(route, context);
                 this.log.debug("Tunnel to target created.");
                 managedConn.tunnelTarget(secure, this.params);
             }   break;
             case HttpRouteDirector.TUNNEL_PROXY: {
                 // The most simple example for this case is a proxy chain
                 // of two proxies, where P1 must be tunnelled to P2.
                 // route: Source -> P1 -> P2 -> Target (3 hops)
                 // fact:  Source -> P1 -> Target       (2 hops)
                 final int hop = fact.getHopCount()-1; // the hop to establish
                 boolean secure = createTunnelToProxy(route, hop, context);
                 this.log.debug("Tunnel to proxy created.");
                 managedConn.tunnelProxy(route.getHopTarget(hop),
                                         secure, this.params);
             }   break;
             case HttpRouteDirector.LAYER_PROTOCOL:
                 managedConn.layerProtocol(context, this.params);
                 break;
             case HttpRouteDirector.UNREACHABLE:
                 throw new HttpException("Unable to establish route: " +
                         "planned = " + route + "; current = " + fact);
             case HttpRouteDirector.COMPLETE:
                 // do nothing
                 break;
             default:
                 throw new IllegalStateException("Unknown step indicator "
                         + step + " from RouteDirector.");
             }
         } while (step > HttpRouteDirector.COMPLETE);
     } // establishConnection
     /**
      * Creates a tunnel to the target server.
      * The connection must be established to the (last) proxy.
      * A CONNECT request for tunnelling through the proxy will
      * be created and sent, the response received and checked.
      * This method does <i>not</i> update the connection with
      * information about the tunnel, that is left to the caller.
      *
      * @param route     the route to establish
      * @param context   the context for request execution
      *
      * @return  <code>true</code> if the tunnelled route is secure,
      *          <code>false</code> otherwise.
      *          The implementation here always returns <code>false</code>,
      *          but derived classes may override.
      *
      * @throws HttpException    in case of a problem
      * @throws IOException      in case of an IO problem
      */
     protected boolean createTunnelToTarget(HttpRoute route,
                                            HttpContext context)
         throws HttpException, IOException {
         HttpHost proxy = route.getProxyHost();
         HttpHost target = route.getTargetHost();
         HttpResponse response = null;
         boolean done = false;
         while (!done) {
             done = true;
             if (!this.managedConn.isOpen()) {
                 this.managedConn.open(route, context, this.params);
             }
             HttpRequest connect = createConnectRequest(route, context);
             connect.setParams(this.params);
             // Populate the execution context
             context.setAttribute(ExecutionContext.HTTP_TARGET_HOST,
                     target);
             context.setAttribute(ExecutionContext.HTTP_PROXY_HOST,
                     proxy);
             context.setAttribute(ExecutionContext.HTTP_CONNECTION,
                     managedConn);
             context.setAttribute(ClientContext.TARGET_AUTH_STATE,
                     targetAuthState);
             context.setAttribute(ClientContext.PROXY_AUTH_STATE,
                     proxyAuthState);
             context.setAttribute(ExecutionContext.HTTP_REQUEST,
                     connect);
             this.requestExec.preProcess(connect, this.httpProcessor, context);
             response = this.requestExec.execute(connect, this.managedConn, context);
             response.setParams(this.params);
             this.requestExec.postProcess(response, this.httpProcessor, context);
             int status = response.getStatusLine().getStatusCode();
             if (status < 200) {
                 throw new HttpException("Unexpected response to CONNECT request: " +
                         response.getStatusLine());
             }
             CredentialsProvider credsProvider = (CredentialsProvider)
                 context.getAttribute(ClientContext.CREDS_PROVIDER);
             if (credsProvider != null && HttpClientParams.isAuthenticating(params)) {
                 if (this.proxyAuthHandler.isAuthenticationRequested(response, context)) {
                     this.log.debug("Proxy requested authentication");
                     Map<String, Header> challenges = this.proxyAuthHandler.getChallenges(
                             response, context);
                     try {
                         processChallenges(
                                 challenges, this.proxyAuthState, this.proxyAuthHandler,
                                 response, context);
                     } catch (AuthenticationException ex) {
                         if (this.log.isWarnEnabled()) {
                             this.log.warn("Authentication error: " +  ex.getMessage());
                             break;
                         }
                     }
                     updateAuthState(this.proxyAuthState, proxy, credsProvider);
                     if (this.proxyAuthState.getCredentials() != null) {
                         done = false;
                         // Retry request
                         if (this.reuseStrategy.keepAlive(response, context)) {
                             this.log.debug("Connection kept alive");
                             // Consume response content
                             HttpEntity entity = response.getEntity();
                             EntityUtils.consume(entity);
                         } else {
                             this.managedConn.close();
                         }
                     }
                 } else {
                     // Reset proxy auth scope
                     this.proxyAuthState.setAuthScope(null);
                 }
             }
         }
         int status = response.getStatusLine().getStatusCode(); // can't be null
         if (status > 299) {
             // Buffer response content
             HttpEntity entity = response.getEntity();
             if (entity != null) {
                 response.setEntity(new BufferedHttpEntity(entity));
             }
             this.managedConn.close();
             throw new TunnelRefusedException("CONNECT refused by proxy: " +
                     response.getStatusLine(), response);
         }
         this.managedConn.markReusable();
         // How to decide on security of the tunnelled connection?
         // The socket factory knows only about the segment to the proxy.
         // Even if that is secure, the hop to the target may be insecure.
         // Leave it to derived classes, consider insecure by default here.
         return false;
     } // createTunnelToTarget
     /**
      * Creates a tunnel to an intermediate proxy.
      * This method is <i>not</i> implemented in this class.
      * It just throws an exception here.
      *
      * @param route     the route to establish
      * @param hop       the hop in the route to establish now.
      *                  <code>route.getHopTarget(hop)</code>
      *                  will return the proxy to tunnel to.
      * @param context   the context for request execution
      *
      * @return  <code>true</code> if the partially tunnelled connection
      *          is secure, <code>false</code> otherwise.
      *
      * @throws HttpException    in case of a problem
      * @throws IOException      in case of an IO problem
      */
     protected boolean createTunnelToProxy(HttpRoute route, int hop,
                                           HttpContext context)
         throws HttpException, IOException {
         // Have a look at createTunnelToTarget and replicate the parts
         // you need in a custom derived class. If your proxies don't require
         // authentication, it is not too hard. But for the stock version of
         // HttpClient, we cannot make such simplifying assumptions and would
         // have to include proxy authentication code. The HttpComponents team
         // is currently not in a position to support rarely used code of this
         // complexity. Feel free to submit patches that refactor the code in
         // createTunnelToTarget to facilitate re-use for proxy tunnelling.
         throw new HttpException("Proxy chains are not supported.");
     }
     /**
      * Creates the CONNECT request for tunnelling.
      * Called by {@link #createTunnelToTarget createTunnelToTarget}.
      *
      * @param route     the route to establish
      * @param context   the context for request execution
      *
      * @return  the CONNECT request for tunnelling
      */
     protected HttpRequest createConnectRequest(HttpRoute route,
                                                HttpContext context) {
         // see RFC 2817, section 5.2 and
         // INTERNET-DRAFT: Tunneling TCP based protocols through
         // Web proxy servers
         HttpHost target = route.getTargetHost();
         String host = target.getHostName();
         int port = target.getPort();
         if (port < 0) {
             Scheme scheme = connManager.getSchemeRegistry().
                 getScheme(target.getSchemeName());
             port = scheme.getDefaultPort();
         }
         StringBuilder buffer = new StringBuilder(host.length() + 6);
         buffer.append(host);
         buffer.append(':');
         buffer.append(Integer.toString(port));
         String authority = buffer.toString();
         ProtocolVersion ver = HttpProtocolParams.getVersion(params);
         HttpRequest req = new BasicHttpRequest
             ("CONNECT", authority, ver);
         return req;
     }
     /**
      * Analyzes a response to check need for a followup.
      *
      * @param roureq    the request and route.
      * @param response  the response to analayze
      * @param context   the context used for the current request execution
      *
      * @return  the followup request and route if there is a followup, or
      *          <code>null</code> if the response should be returned as is
      *
      * @throws HttpException    in case of a problem
      * @throws IOException      in case of an IO problem
      */
     protected RoutedRequest handleResponse(RoutedRequest roureq,
                                            HttpResponse response,
                                            HttpContext context)
         throws HttpException, IOException {
         HttpRoute route = roureq.getRoute();
         RequestWrapper request = roureq.getRequest();
         HttpParams params = request.getParams();
         if (HttpClientParams.isRedirecting(params) &&
                 this.redirectStrategy.isRedirected(request, response, context)) {
             if (redirectCount >= maxRedirects) {
                 throw new RedirectException("Maximum redirects ("
                         + maxRedirects + ") exceeded");
             }
             redirectCount++;
             // Virtual host cannot be used any longer
             virtualHost = null;
             HttpUriRequest redirect = redirectStrategy.getRedirect(request, response, context);
             HttpRequest orig = request.getOriginal();
             redirect.setHeaders(orig.getAllHeaders());
             URI uri = redirect.getURI();
             if (uri.getHost() == null) {
                 throw new ProtocolException("Redirect URI does not specify a valid host name: " + uri);
             }
             HttpHost newTarget = new HttpHost(
                     uri.getHost(),
                     uri.getPort(),
                     uri.getScheme());
             // Unset auth scope
             targetAuthState.setAuthScope(null);
             proxyAuthState.setAuthScope(null);
             // Invalidate auth states if redirecting to another host
             if (!route.getTargetHost().equals(newTarget)) {
                 targetAuthState.invalidate();
                 AuthScheme authScheme = proxyAuthState.getAuthScheme();
                 if (authScheme != null && authScheme.isConnectionBased()) {
                     proxyAuthState.invalidate();
                 }
             }
             RequestWrapper wrapper = wrapRequest(redirect);
             wrapper.setParams(params);
             HttpRoute newRoute = determineRoute(newTarget, wrapper, context);
             RoutedRequest newRequest = new RoutedRequest(wrapper, newRoute);
             if (this.log.isDebugEnabled()) {
                 this.log.debug("Redirecting to '" + uri + "' via " + newRoute);
             }
             return newRequest;
         }
         CredentialsProvider credsProvider = (CredentialsProvider)
             context.getAttribute(ClientContext.CREDS_PROVIDER);
         if (credsProvider != null && HttpClientParams.isAuthenticating(params)) {
             if (this.targetAuthHandler.isAuthenticationRequested(response, context)) {
                 HttpHost target = (HttpHost)
                     context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
                 if (target == null) {
                     target = route.getTargetHost();
                 }
                 this.log.debug("Target requested authentication");
                 Map<String, Header> challenges = this.targetAuthHandler.getChallenges(
                         response, context);
                 try {
                     processChallenges(challenges,
                             this.targetAuthState, this.targetAuthHandler,
                             response, context);
                 } catch (AuthenticationException ex) {
                     if (this.log.isWarnEnabled()) {
                         this.log.warn("Authentication error: " +  ex.getMessage());
                         return null;
                     }
                 }
                 updateAuthState(this.targetAuthState, target, credsProvider);
                 if (this.targetAuthState.getCredentials() != null) {
                     // Re-try the same request via the same route
                     return roureq;
                 } else {
                     return null;
                 }
             } else {
                 // Reset target auth scope
                 this.targetAuthState.setAuthScope(null);
             }
             if (this.proxyAuthHandler.isAuthenticationRequested(response, context)) {
                 HttpHost proxy = route.getProxyHost();
                 this.log.debug("Proxy requested authentication");
                 Map<String, Header> challenges = this.proxyAuthHandler.getChallenges(
                         response, context);
                 try {
                     processChallenges(challenges,
                             this.proxyAuthState, this.proxyAuthHandler,
                             response, context);
                 } catch (AuthenticationException ex) {
                     if (this.log.isWarnEnabled()) {
                         this.log.warn("Authentication error: " +  ex.getMessage());
                         return null;
                     }
                 }
                 updateAuthState(this.proxyAuthState, proxy, credsProvider);
                 if (this.proxyAuthState.getCredentials() != null) {
                     // Re-try the same request via the same route
                     return roureq;
                 } else {
                     return null;
                 }
             } else {
                 // Reset proxy auth scope
                 this.proxyAuthState.setAuthScope(null);
             }
         }
         return null;
     } // handleResponse
     /**
      * Shuts down the connection.
      * This method is called from a <code>catch</code> block in
      * {@link #execute execute} during exception handling.
      */
     private void abortConnection() {
         ManagedClientConnection mcc = managedConn;
         if (mcc != null) {
             // we got here as the result of an exception
             // no response will be returned, release the connection
             managedConn = null;
             try {
                 mcc.abortConnection();
             } catch (IOException ex) {
                 if (this.log.isDebugEnabled()) {
                     this.log.debug(ex.getMessage(), ex);
                 }
             }
             // ensure the connection manager properly releases this connection
             try {
                 mcc.releaseConnection();
             } catch(IOException ignored) {
                 this.log.debug("Error releasing connection", ignored);
             }
         }
     } // abortConnection
     private void processChallenges(
             final Map<String, Header> challenges,
             final AuthState authState,
             final AuthenticationHandler authHandler,
             final HttpResponse response,
             final HttpContext context)
                 throws MalformedChallengeException, AuthenticationException {
         AuthScheme authScheme = authState.getAuthScheme();
         if (authScheme == null) {
             // Authentication not attempted before
             authScheme = authHandler.selectScheme(challenges, response, context);
             authState.setAuthScheme(authScheme);
         }
         String id = authScheme.getSchemeName();
         Header challenge = challenges.get(id.toLowerCase(Locale.ENGLISH));
         if (challenge == null) {
             throw new AuthenticationException(id +
                 " authorization challenge expected, but not found");
         }
         authScheme.processChallenge(challenge);
         this.log.debug("Authorization challenge processed");
     }
     private void updateAuthState(
             final AuthState authState,
             final HttpHost host,
             final CredentialsProvider credsProvider) {
         if (!authState.isValid()) {
             return;
         }
         String hostname = host.getHostName();
         int port = host.getPort();
         if (port < 0) {
             Scheme scheme = connManager.getSchemeRegistry().getScheme(host);
             port = scheme.getDefaultPort();
         }
         AuthScheme authScheme = authState.getAuthScheme();
         AuthScope authScope = new AuthScope(
                 hostname,
                 port,
                 authScheme.getRealm(),
                 authScheme.getSchemeName());
         if (this.log.isDebugEnabled()) {
             this.log.debug("Authentication scope: " + authScope);
         }
         Credentials creds = authState.getCredentials();
         if (creds == null) {
             creds = credsProvider.getCredentials(authScope);
             if (this.log.isDebugEnabled()) {
                 if (creds != null) {
                     this.log.debug("Found credentials");
                 } else {
                     this.log.debug("Credentials not found");
                 }
             }
         } else {
             if (authScheme.isComplete()) {
                 this.log.debug("Authentication failed");
                 creds = null;
             }
         }
         authState.setAuthScope(authScope);
         authState.setCredentials(creds);
     }
     private void invalidateAuthIfSuccessful(final AuthState authState) {
         AuthScheme authscheme = authState.getAuthScheme();
         if (authscheme != null
                 && authscheme.isConnectionBased()
                 && authscheme.isComplete()
                 && authState.getCredentials() != null) {
             authState.invalidate();
         }
     }
 } // class DefaultClientRequestDirector

The Tor Browser / annotate

mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/client/DefaultRequestDirector.java@fc2d59ddac77 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/impl/client/DefaultRequestDirector.java