diff options
Diffstat (limited to 'mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/RouteTracker.java')
| -rw-r--r-- | mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/RouteTracker.java | 366 |
1 files changed, 366 insertions, 0 deletions
diff --git a/mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/RouteTracker.java b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/RouteTracker.java new file mode 100644 index 000000000..9a900319c --- /dev/null +++ b/mobile/android/thirdparty/ch/boye/httpclientandroidlib/conn/routing/RouteTracker.java @@ -0,0 +1,366 @@ +/* + * ==================================================================== + * 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.HttpHost; +import ch.boye.httpclientandroidlib.annotation.NotThreadSafe; +import ch.boye.httpclientandroidlib.util.Args; +import ch.boye.httpclientandroidlib.util.Asserts; +import ch.boye.httpclientandroidlib.util.LangUtils; + +/** + * Helps tracking the steps in establishing a route. + * + * @since 4.0 + */ +@NotThreadSafe +public final class RouteTracker implements RouteInfo, Cloneable { + + /** 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 attributes above are fixed at construction time + // now follow attributes that indicate the established route + + /** Whether the first hop of the route is established. */ + private boolean connected; + + /** The proxy chain, if any. */ + private HttpHost[] proxyChain; + + /** Whether the the route is tunnelled end-to-end through proxies. */ + private TunnelType tunnelled; + + /** Whether the route is layered over a tunnel. */ + private LayerType layered; + + /** Whether the route is secure. */ + private boolean secure; + + /** + * Creates a new route tracker. + * The target and origin need to be specified at creation time. + * + * @param target the host to which to route + * @param local the local address to route from, or + * <code>null</code> for the default + */ + public RouteTracker(final HttpHost target, final InetAddress local) { + Args.notNull(target, "Target host"); + this.targetHost = target; + this.localAddress = local; + this.tunnelled = TunnelType.PLAIN; + this.layered = LayerType.PLAIN; + } + + /** + * @since 4.2 + */ + public void reset() { + this.connected = false; + this.proxyChain = null; + this.tunnelled = TunnelType.PLAIN; + this.layered = LayerType.PLAIN; + this.secure = false; + } + + /** + * Creates a new tracker for the given route. + * Only target and origin are taken from the route, + * everything else remains to be tracked. + * + * @param route the route to track + */ + public RouteTracker(final HttpRoute route) { + this(route.getTargetHost(), route.getLocalAddress()); + } + + /** + * Tracks connecting to the target. + * + * @param secure <code>true</code> if the route is secure, + * <code>false</code> otherwise + */ + public final void connectTarget(final boolean secure) { + Asserts.check(!this.connected, "Already connected"); + this.connected = true; + this.secure = secure; + } + + /** + * Tracks connecting to the first proxy. + * + * @param proxy the proxy connected to + * @param secure <code>true</code> if the route is secure, + * <code>false</code> otherwise + */ + public final void connectProxy(final HttpHost proxy, final boolean secure) { + Args.notNull(proxy, "Proxy host"); + Asserts.check(!this.connected, "Already connected"); + this.connected = true; + this.proxyChain = new HttpHost[]{ proxy }; + this.secure = secure; + } + + /** + * Tracks tunnelling to the target. + * + * @param secure <code>true</code> if the route is secure, + * <code>false</code> otherwise + */ + public final void tunnelTarget(final boolean secure) { + Asserts.check(this.connected, "No tunnel unless connected"); + Asserts.notNull(this.proxyChain, "No tunnel without proxy"); + this.tunnelled = TunnelType.TUNNELLED; + this.secure = secure; + } + + /** + * Tracks tunnelling to a proxy in a proxy chain. + * This will extend the tracked proxy chain, but it does not mark + * the route as tunnelled. Only end-to-end tunnels are considered there. + * + * @param proxy the proxy tunnelled to + * @param secure <code>true</code> if the route is secure, + * <code>false</code> otherwise + */ + public final void tunnelProxy(final HttpHost proxy, final boolean secure) { + Args.notNull(proxy, "Proxy host"); + Asserts.check(this.connected, "No tunnel unless connected"); + Asserts.notNull(this.proxyChain, "No tunnel without proxy"); + // prepare an extended proxy chain + final HttpHost[] proxies = new HttpHost[this.proxyChain.length+1]; + System.arraycopy(this.proxyChain, 0, + proxies, 0, this.proxyChain.length); + proxies[proxies.length-1] = proxy; + + this.proxyChain = proxies; + this.secure = secure; + } + + /** + * Tracks layering a protocol. + * + * @param secure <code>true</code> if the route is secure, + * <code>false</code> otherwise + */ + public final void layerProtocol(final boolean secure) { + // it is possible to layer a protocol over a direct connection, + // although this case is probably not considered elsewhere + Asserts.check(this.connected, "No layered protocol unless connected"); + this.layered = LayerType.LAYERED; + this.secure = secure; + } + + public final HttpHost getTargetHost() { + return this.targetHost; + } + + public final InetAddress getLocalAddress() { + return this.localAddress; + } + + public final int getHopCount() { + int hops = 0; + if (this.connected) { + if (proxyChain == null) { + hops = 1; + } else { + hops = proxyChain.length + 1; + } + } + return hops; + } + + public final HttpHost getHopTarget(final int hop) { + Args.notNegative(hop, "Hop index"); + final int hopcount = getHopCount(); + Args.check(hop < hopcount, "Hop index exceeds tracked route length"); + HttpHost result = null; + if (hop < hopcount-1) { + result = this.proxyChain[hop]; + } else { + result = this.targetHost; + } + + return result; + } + + public final HttpHost getProxyHost() { + return (this.proxyChain == null) ? null : this.proxyChain[0]; + } + + public final boolean isConnected() { + return this.connected; + } + + 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; + } + + /** + * Obtains the tracked route. + * If a route has been tracked, it is {@link #isConnected connected}. + * If not connected, nothing has been tracked so far. + * + * @return the tracked route, or + * <code>null</code> if nothing has been tracked so far + */ + public final HttpRoute toRoute() { + return !this.connected ? + null : new HttpRoute(this.targetHost, this.localAddress, + this.proxyChain, this.secure, + this.tunnelled, this.layered); + } + + /** + * Compares this tracked route to another. + * + * @param o the object to compare with + * + * @return <code>true</code> if the argument is the same tracked route, + * <code>false</code> + */ + @Override + public final boolean equals(final Object o) { + if (o == this) { + return true; + } + if (!(o instanceof RouteTracker)) { + return false; + } + + final RouteTracker that = (RouteTracker) o; + return + // Do the cheapest checks first + (this.connected == that.connected) && + (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); + } + + /** + * Generates a hash code for this tracked route. + * Route trackers are modifiable and should therefore not be used + * as lookup keys. Use {@link #toRoute toRoute} to obtain an + * unmodifiable representation of the tracked 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); + if (this.proxyChain != null) { + for (final HttpHost element : this.proxyChain) { + hash = LangUtils.hashCode(hash, element); + } + } + hash = LangUtils.hashCode(hash, this.connected); + hash = LangUtils.hashCode(hash, this.secure); + hash = LangUtils.hashCode(hash, this.tunnelled); + hash = LangUtils.hashCode(hash, this.layered); + return hash; + } + + /** + * Obtains a description of the tracked route. + * + * @return a human-readable representation of the tracked route + */ + @Override + public final String toString() { + final StringBuilder cab = new StringBuilder(50 + getHopCount()*30); + + cab.append("RouteTracker["); + if (this.localAddress != null) { + cab.append(this.localAddress); + cab.append("->"); + } + cab.append('{'); + if (this.connected) { + cab.append('c'); + } + if (this.tunnelled == TunnelType.TUNNELLED) { + cab.append('t'); + } + if (this.layered == LayerType.LAYERED) { + cab.append('l'); + } + if (this.secure) { + cab.append('s'); + } + cab.append("}->"); + if (this.proxyChain != null) { + for (final HttpHost element : this.proxyChain) { + cab.append(element); + 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(); + } + +} |