The Tor Browser: mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/HttpRoute.java@6474c204b198 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/HttpRoute.java@6474c204b198 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/HttpRoute.java

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
  * ====================================================================
  * 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.conn.routing;
 import java.net.InetAddress;
 import ch.boye.httpclientandroidlib.annotation.Immutable;
 import ch.boye.httpclientandroidlib.util.LangUtils;
 import ch.boye.httpclientandroidlib.HttpHost;
 /**
  * The route for a request.
  * Instances of this class are unmodifiable and therefore suitable
  * for use as lookup keys.
  *
  * @since 4.0
  */
 @Immutable
 public final class HttpRoute implements RouteInfo, Cloneable {
     private static final HttpHost[] EMPTY_HTTP_HOST_ARRAY = new HttpHost[]{};
     /** The target host to connect to. */
     private final HttpHost targetHost;
     /**
      * The local address to connect from.
      * <code>null</code> indicates that the default should be used.
      */
     private final InetAddress localAddress;
     /** The proxy servers, if any. Never null. */
     private final HttpHost[] proxyChain;
     /** Whether the the route is tunnelled through the proxy. */
     private final TunnelType tunnelled;
     /** Whether the route is layered. */
     private final LayerType layered;
     /** Whether the route is (supposed to be) secure. */
     private final boolean secure;
     /**
      * Internal, fully-specified constructor.
      * This constructor does <i>not</i> clone the proxy chain array,
      * nor test it for <code>null</code> elements. This conversion and
      * check is the responsibility of the public constructors.
      * The order of arguments here is different from the similar public
      * constructor, as required by Java.
      *
      * @param local     the local address to route from, or
      *                  <code>null</code> for the default
      * @param target    the host to which to route
      * @param proxies   the proxy chain to use, or
      *                  <code>null</code> for a direct route
      * @param secure    <code>true</code> if the route is (to be) secure,
      *                  <code>false</code> otherwise
      * @param tunnelled the tunnel type of this route, or
      *                  <code>null</code> for PLAIN
      * @param layered   the layering type of this route, or
      *                  <code>null</code> for PLAIN
      */
     private HttpRoute(InetAddress local,
                       HttpHost target, HttpHost[] proxies,
                       boolean secure,
                       TunnelType tunnelled, LayerType layered) {
         if (target == null) {
             throw new IllegalArgumentException
                 ("Target host may not be null.");
         }
         if (proxies == null) {
             throw new IllegalArgumentException
                 ("Proxies may not be null.");
         }
         if ((tunnelled == TunnelType.TUNNELLED) && (proxies.length == 0)) {
             throw new IllegalArgumentException
                 ("Proxy required if tunnelled.");
         }
         // tunnelled is already checked above, that is in line with the default
         if (tunnelled == null)
             tunnelled = TunnelType.PLAIN;
         if (layered == null)
             layered = LayerType.PLAIN;
         this.targetHost   = target;
         this.localAddress = local;
         this.proxyChain   = proxies;
         this.secure       = secure;
         this.tunnelled    = tunnelled;
         this.layered      = layered;
     }
     /**
      * Creates a new route with all attributes specified explicitly.
      *
      * @param target    the host to which to route
      * @param local     the local address to route from, or
      *                  <code>null</code> for the default
      * @param proxies   the proxy chain to use, or
      *                  <code>null</code> for a direct route
      * @param secure    <code>true</code> if the route is (to be) secure,
      *                  <code>false</code> otherwise
      * @param tunnelled the tunnel type of this route
      * @param layered   the layering type of this route
      */
     public HttpRoute(HttpHost target, InetAddress local, HttpHost[] proxies,
                      boolean secure, TunnelType tunnelled, LayerType layered) {
         this(local, target, toChain(proxies), secure, tunnelled, layered);
     }
     /**
      * Creates a new route with at most one proxy.
      *
      * @param target    the host to which to route
      * @param local     the local address to route from, or
      *                  <code>null</code> for the default
      * @param proxy     the proxy to use, or
      *                  <code>null</code> for a direct route
      * @param secure    <code>true</code> if the route is (to be) secure,
      *                  <code>false</code> otherwise
      * @param tunnelled <code>true</code> if the route is (to be) tunnelled
      *                  via the proxy,
      *                  <code>false</code> otherwise
      * @param layered   <code>true</code> if the route includes a
      *                  layered protocol,
      *                  <code>false</code> otherwise
      */
     public HttpRoute(HttpHost target, InetAddress local, HttpHost proxy,
                      boolean secure, TunnelType tunnelled, LayerType layered) {
         this(local, target, toChain(proxy), secure, tunnelled, layered);
     }
     /**
      * Creates a new direct route.
      * That is a route without a proxy.
      *
      * @param target    the host to which to route
      * @param local     the local address to route from, or
      *                  <code>null</code> for the default
      * @param secure    <code>true</code> if the route is (to be) secure,
      *                  <code>false</code> otherwise
      */
     public HttpRoute(HttpHost target, InetAddress local, boolean secure) {
         this(local, target, EMPTY_HTTP_HOST_ARRAY, secure, TunnelType.PLAIN, LayerType.PLAIN);
     }
     /**
      * Creates a new direct insecure route.
      *
      * @param target    the host to which to route
      */
     public HttpRoute(HttpHost target) {
         this(null, target, EMPTY_HTTP_HOST_ARRAY, false, TunnelType.PLAIN, LayerType.PLAIN);
     }
     /**
      * Creates a new route through a proxy.
      * When using this constructor, the <code>proxy</code> MUST be given.
      * For convenience, it is assumed that a secure connection will be
      * layered over a tunnel through the proxy.
      *
      * @param target    the host to which to route
      * @param local     the local address to route from, or
      *                  <code>null</code> for the default
      * @param proxy     the proxy to use
      * @param secure    <code>true</code> if the route is (to be) secure,
      *                  <code>false</code> otherwise
      */
     public HttpRoute(HttpHost target, InetAddress local, HttpHost proxy,
                      boolean secure) {
         this(local, target, toChain(proxy), secure,
              secure ? TunnelType.TUNNELLED : TunnelType.PLAIN,
              secure ? LayerType.LAYERED    : LayerType.PLAIN);
         if (proxy == null) {
             throw new IllegalArgumentException
                 ("Proxy host may not be null.");
         }
     }
     /**
      * Helper to convert a proxy to a proxy chain.
      *
      * @param proxy     the only proxy in the chain, or <code>null</code>
      *
      * @return  a proxy chain array, may be empty (never null)
      */
     private static HttpHost[] toChain(HttpHost proxy) {
         if (proxy == null)
             return EMPTY_HTTP_HOST_ARRAY;
         return new HttpHost[]{ proxy };
     }
     /**
      * Helper to duplicate and check a proxy chain.
      * <code>null</code> is converted to an empty proxy chain.
      *
      * @param proxies   the proxy chain to duplicate, or <code>null</code>
      *
      * @return  a new proxy chain array, may be empty (never null)
      */
     private static HttpHost[] toChain(HttpHost[] proxies) {
         if ((proxies == null) || (proxies.length < 1))
             return EMPTY_HTTP_HOST_ARRAY;
         for (HttpHost proxy : proxies) {
             if (proxy == null)
                 throw new IllegalArgumentException
                         ("Proxy chain may not contain null elements.");
         }
         // copy the proxy chain, the traditional way
         HttpHost[] result = new HttpHost[proxies.length];
         System.arraycopy(proxies, 0, result, 0, proxies.length);
         return result;
     }
     // non-JavaDoc, see interface RouteInfo
     public final HttpHost getTargetHost() {
         return this.targetHost;
     }
     // non-JavaDoc, see interface RouteInfo
     public final InetAddress getLocalAddress() {
         return this.localAddress;
     }
     public final int getHopCount() {
         return proxyChain.length+1;
     }
     public final HttpHost getHopTarget(int hop) {
         if (hop < 0)
             throw new IllegalArgumentException
                 ("Hop index must not be negative: " + hop);
         final int hopcount = getHopCount();
         if (hop >= hopcount)
             throw new IllegalArgumentException
                 ("Hop index " + hop +
                  " exceeds route length " + hopcount);
         HttpHost result = null;
         if (hop < hopcount-1)
             result = this.proxyChain[hop];
         else
             result = this.targetHost;
         return result;
     }
     public final HttpHost getProxyHost() {
         return (this.proxyChain.length == 0) ? null : this.proxyChain[0];
     }
     public final TunnelType getTunnelType() {
         return this.tunnelled;
     }
     public final boolean isTunnelled() {
         return (this.tunnelled == TunnelType.TUNNELLED);
     }
     public final LayerType getLayerType() {
         return this.layered;
     }
     public final boolean isLayered() {
         return (this.layered == LayerType.LAYERED);
     }
     public final boolean isSecure() {
         return this.secure;
     }
     /**
      * Compares this route to another.
      *
      * @param obj         the object to compare with
      *
      * @return  <code>true</code> if the argument is the same route,
      *          <code>false</code>
      */
     @Override
     public final boolean equals(Object obj) {
         if (this == obj) return true;
         if (obj instanceof HttpRoute) {
             HttpRoute that = (HttpRoute) obj;
             return
                 // Do the cheapest tests first
                 (this.secure    == that.secure) &&
                 (this.tunnelled == that.tunnelled) &&
                 (this.layered   == that.layered) &&
                 LangUtils.equals(this.targetHost, that.targetHost) &&
                 LangUtils.equals(this.localAddress, that.localAddress) &&
                 LangUtils.equals(this.proxyChain, that.proxyChain);
         } else {
             return false;
         }
     }
     /**
      * Generates a hash code for this route.
      *
      * @return  the hash code
      */
     @Override
     public final int hashCode() {
         int hash = LangUtils.HASH_SEED;
         hash = LangUtils.hashCode(hash, this.targetHost);
         hash = LangUtils.hashCode(hash, this.localAddress);
         for (int i = 0; i < this.proxyChain.length; i++) {
             hash = LangUtils.hashCode(hash, this.proxyChain[i]);
         }
         hash = LangUtils.hashCode(hash, this.secure);
         hash = LangUtils.hashCode(hash, this.tunnelled);
         hash = LangUtils.hashCode(hash, this.layered);
         return hash;
     }
     /**
      * Obtains a description of this route.
      *
      * @return  a human-readable representation of this route
      */
     @Override
     public final String toString() {
         StringBuilder cab = new StringBuilder(50 + getHopCount()*30);
         cab.append("HttpRoute[");
         if (this.localAddress != null) {
             cab.append(this.localAddress);
             cab.append("->");
         }
         cab.append('{');
         if (this.tunnelled == TunnelType.TUNNELLED)
             cab.append('t');
         if (this.layered == LayerType.LAYERED)
             cab.append('l');
         if (this.secure)
             cab.append('s');
         cab.append("}->");
         for (HttpHost aProxyChain : this.proxyChain) {
             cab.append(aProxyChain);
             cab.append("->");
         }
         cab.append(this.targetHost);
         cab.append(']');
         return cab.toString();
     }
     // default implementation of clone() is sufficient
     @Override
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
 }

The Tor Browser / annotate

mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/HttpRoute.java@6474c204b198 (annotated)

mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/HttpRoute.java