Socks5BytestreamRequest.java

  1. /**
  2.  *
  3.  * Copyright the original author or authors
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.bytestreams.socks5;

  19. import java.io.IOException;
  20. import java.net.Socket;
  21. import java.util.Collection;
  22. import java.util.concurrent.TimeoutException;

  24. import org.jivesoftware.smack.SmackException;
  25. import org.jivesoftware.smack.SmackException.NotConnectedException;
  26. import org.jivesoftware.smack.XMPPException;
  27. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  28. import org.jivesoftware.smack.packet.IQ;
  29. import org.jivesoftware.smack.packet.XMPPError;
  30. import org.jivesoftware.smackx.bytestreams.BytestreamRequest;
  31. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream;
  32. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost;
  33. import org.jxmpp.jid.Jid;
  34. import org.jxmpp.util.cache.Cache;
  35. import org.jxmpp.util.cache.ExpirationCache;

  37. /**
  38.  * Socks5BytestreamRequest class handles incoming SOCKS5 Bytestream requests.
  39.  * 
  40.  * @author Henning Staib
  41.  */
  42. public class Socks5BytestreamRequest implements BytestreamRequest {

  44.     /* lifetime of an Item in the blacklist */
  45.     private static final long BLACKLIST_LIFETIME = 60 * 1000 * 120;

  47.     /* size of the blacklist */
  48.     private static final int BLACKLIST_MAX_SIZE = 100;

  50.     /* blacklist of addresses of SOCKS5 proxies */
  51.     private static final Cache<String, Integer> ADDRESS_BLACKLIST = new ExpirationCache<String, Integer>(
  52.                     BLACKLIST_MAX_SIZE, BLACKLIST_LIFETIME);

  54.     /*
  55.      * The number of connection failures it takes for a particular SOCKS5 proxy to be blacklisted.
  56.      * When a proxy is blacklisted no more connection attempts will be made to it for a period of 2
  57.      * hours.
  58.      */
  59.     private static int CONNECTION_FAILURE_THRESHOLD = 2;

  61.     /* the bytestream initialization request */
  62.     private Bytestream bytestreamRequest;

  64.     /* SOCKS5 Bytestream manager containing the XMPP connection and helper methods */
  65.     private Socks5BytestreamManager manager;

  67.     /* timeout to connect to all SOCKS5 proxies */
  68.     private int totalConnectTimeout = 10000;

  70.     /* minimum timeout to connect to one SOCKS5 proxy */
  71.     private int minimumConnectTimeout = 2000;

  73.     /**
  74.      * Returns the number of connection failures it takes for a particular SOCKS5 proxy to be
  75.      * blacklisted. When a proxy is blacklisted no more connection attempts will be made to it for a
  76.      * period of 2 hours. Default is 2.
  77.      * 
  78.      * @return the number of connection failures it takes for a particular SOCKS5 proxy to be
  79.      *         blacklisted
  80.      */
  81.     public static int getConnectFailureThreshold() {
  82.         return CONNECTION_FAILURE_THRESHOLD;
  83.     }

  85.     /**
  86.      * Sets the number of connection failures it takes for a particular SOCKS5 proxy to be
  87.      * blacklisted. When a proxy is blacklisted no more connection attempts will be made to it for a
  88.      * period of 2 hours. Default is 2.
  89.      * <p>
  90.      * Setting the connection failure threshold to zero disables the blacklisting.
  91.      * 
  92.      * @param connectFailureThreshold the number of connection failures it takes for a particular
  93.      *        SOCKS5 proxy to be blacklisted
  94.      */
  95.     public static void setConnectFailureThreshold(int connectFailureThreshold) {
  96.         CONNECTION_FAILURE_THRESHOLD = connectFailureThreshold;
  97.     }

  99.     /**
  100.      * Creates a new Socks5BytestreamRequest.
  101.      * 
  102.      * @param manager the SOCKS5 Bytestream manager
  103.      * @param bytestreamRequest the SOCKS5 Bytestream initialization packet
  104.      */
  105.     protected Socks5BytestreamRequest(Socks5BytestreamManager manager, Bytestream bytestreamRequest) {
  106.         this.manager = manager;
  107.         this.bytestreamRequest = bytestreamRequest;
  108.     }

  110.     /**
  111.      * Returns the maximum timeout to connect to SOCKS5 proxies. Default is 10000ms.
  112.      * <p>
  113.      * When accepting a SOCKS5 Bytestream request Smack tries to connect to all SOCKS5 proxies given
  114.      * by the initiator until a connection is established. This timeout divided by the number of
  115.      * SOCKS5 proxies determines the timeout for every connection attempt.
  116.      * <p>
  117.      * You can set the minimum timeout for establishing a connection to one SOCKS5 proxy by invoking
  118.      * {@link #setMinimumConnectTimeout(int)}.
  119.      * 
  120.      * @return the maximum timeout to connect to SOCKS5 proxies
  121.      */
  122.     public int getTotalConnectTimeout() {
  123.         if (this.totalConnectTimeout <= 0) {
  124.             return 10000;
  125.         }
  126.         return this.totalConnectTimeout;
  127.     }

  129.     /**
  130.      * Sets the maximum timeout to connect to SOCKS5 proxies. Default is 10000ms.
  131.      * <p>
  132.      * When accepting a SOCKS5 Bytestream request Smack tries to connect to all SOCKS5 proxies given
  133.      * by the initiator until a connection is established. This timeout divided by the number of
  134.      * SOCKS5 proxies determines the timeout for every connection attempt.
  135.      * <p>
  136.      * You can set the minimum timeout for establishing a connection to one SOCKS5 proxy by invoking
  137.      * {@link #setMinimumConnectTimeout(int)}.
  138.      * 
  139.      * @param totalConnectTimeout the maximum timeout to connect to SOCKS5 proxies
  140.      */
  141.     public void setTotalConnectTimeout(int totalConnectTimeout) {
  142.         this.totalConnectTimeout = totalConnectTimeout;
  143.     }

  145.     /**
  146.      * Returns the timeout to connect to one SOCKS5 proxy while accepting the SOCKS5 Bytestream
  147.      * request. Default is 2000ms.
  148.      * 
  149.      * @return the timeout to connect to one SOCKS5 proxy
  150.      */
  151.     public int getMinimumConnectTimeout() {
  152.         if (this.minimumConnectTimeout <= 0) {
  153.             return 2000;
  154.         }
  155.         return this.minimumConnectTimeout;
  156.     }

  158.     /**
  159.      * Sets the timeout to connect to one SOCKS5 proxy while accepting the SOCKS5 Bytestream
  160.      * request. Default is 2000ms.
  161.      * 
  162.      * @param minimumConnectTimeout the timeout to connect to one SOCKS5 proxy
  163.      */
  164.     public void setMinimumConnectTimeout(int minimumConnectTimeout) {
  165.         this.minimumConnectTimeout = minimumConnectTimeout;
  166.     }

  168.     /**
  169.      * Returns the sender of the SOCKS5 Bytestream initialization request.
  170.      * 
  171.      * @return the sender of the SOCKS5 Bytestream initialization request.
  172.      */
  173.     public Jid getFrom() {
  174.         return this.bytestreamRequest.getFrom();
  175.     }

  177.     /**
  178.      * Returns the session ID of the SOCKS5 Bytestream initialization request.
  179.      * 
  180.      * @return the session ID of the SOCKS5 Bytestream initialization request.
  181.      */
  182.     public String getSessionID() {
  183.         return this.bytestreamRequest.getSessionID();
  184.     }

  186.     /**
  187.      * Accepts the SOCKS5 Bytestream initialization request and returns the socket to send/receive
  188.      * data.
  189.      * <p>
  190.      * Before accepting the SOCKS5 Bytestream request you can set timeouts by invoking
  191.      * {@link #setTotalConnectTimeout(int)} and {@link #setMinimumConnectTimeout(int)}.
  192.      * 
  193.      * @return the socket to send/receive data
  194.      * @throws InterruptedException if the current thread was interrupted while waiting
  195.      * @throws XMPPErrorException 
  196.      * @throws SmackException 
  197.      */
  198.     public Socks5BytestreamSession accept() throws InterruptedException, XMPPErrorException, SmackException {
  199.         Collection<StreamHost> streamHosts = this.bytestreamRequest.getStreamHosts();

  201.         // throw exceptions if request contains no stream hosts
  202.         if (streamHosts.size() == 0) {
  203.             cancelRequest();
  204.         }

  206.         StreamHost selectedHost = null;
  207.         Socket socket = null;

  209.         String digest = Socks5Utils.createDigest(this.bytestreamRequest.getSessionID(),
  210.                         this.bytestreamRequest.getFrom(), this.manager.getConnection().getUser());

  212.         /*
  213.          * determine timeout for each connection attempt; each SOCKS5 proxy has the same amount of
  214.          * time so that the first does not consume the whole timeout
  215.          */
  216.         int timeout = Math.max(getTotalConnectTimeout() / streamHosts.size(),
  217.                         getMinimumConnectTimeout());

  219.         for (StreamHost streamHost : streamHosts) {
  220.             String address = streamHost.getAddress() + ":" + streamHost.getPort();

  222.             // check to see if this address has been blacklisted
  223.             int failures = getConnectionFailures(address);
  224.             if (CONNECTION_FAILURE_THRESHOLD > 0 && failures >= CONNECTION_FAILURE_THRESHOLD) {
  225.                 continue;
  226.             }

  228.             // establish socket
  229.             try {

  231.                 // build SOCKS5 client
  232.                 final Socks5Client socks5Client = new Socks5Client(streamHost, digest);

  234.                 // connect to SOCKS5 proxy with a timeout
  235.                 socket = socks5Client.getSocket(timeout);

  237.                 // set selected host
  238.                 selectedHost = streamHost;
  239.                 break;

  241.             }
  242.             catch (TimeoutException e) {
  243.                 incrementConnectionFailures(address);
  244.             }
  245.             catch (IOException e) {
  246.                 incrementConnectionFailures(address);
  247.             }
  248.             catch (XMPPException e) {
  249.                 incrementConnectionFailures(address);
  250.             }

  252.         }

  254.         // throw exception if connecting to all SOCKS5 proxies failed
  255.         if (selectedHost == null || socket == null) {
  256.             cancelRequest();
  257.         }

  259.         // send used-host confirmation
  260.         Bytestream response = createUsedHostResponse(selectedHost);
  261.         this.manager.getConnection().sendStanza(response);

  263.         return new Socks5BytestreamSession(socket, selectedHost.getJID().equals(
  264.                         this.bytestreamRequest.getFrom()));

  266.     }

  268.     /**
  269.      * Rejects the SOCKS5 Bytestream request by sending a reject error to the initiator.
  270.      * @throws NotConnectedException 
  271.      * @throws InterruptedException 
  272.      */
  273.     public void reject() throws NotConnectedException, InterruptedException {
  274.         this.manager.replyRejectPacket(this.bytestreamRequest);
  275.     }

  277.     /**
  278.      * Cancels the SOCKS5 Bytestream request by sending an error to the initiator and building a
  279.      * XMPP exception.
  280.      * @throws XMPPErrorException 
  281.      * @throws NotConnectedException 
  282.      * @throws InterruptedException 
  283.      */
  284.     private void cancelRequest() throws XMPPErrorException, NotConnectedException, InterruptedException {
  285.         String errorMessage = "Could not establish socket with any provided host";
  286.         XMPPError error = XMPPError.from(XMPPError.Condition.item_not_found, errorMessage);
  287.         IQ errorIQ = IQ.createErrorResponse(this.bytestreamRequest, error);
  288.         this.manager.getConnection().sendStanza(errorIQ);
  289.         throw new XMPPErrorException(errorMessage, error);
  290.     }

  292.     /**
  293.      * Returns the response to the SOCKS5 Bytestream request containing the SOCKS5 proxy used.
  294.      * 
  295.      * @param selectedHost the used SOCKS5 proxy
  296.      * @return the response to the SOCKS5 Bytestream request
  297.      */
  298.     private Bytestream createUsedHostResponse(StreamHost selectedHost) {
  299.         Bytestream response = new Bytestream(this.bytestreamRequest.getSessionID());
  300.         response.setTo(this.bytestreamRequest.getFrom());
  301.         response.setType(IQ.Type.result);
  302.         response.setStanzaId(this.bytestreamRequest.getStanzaId());
  303.         response.setUsedHost(selectedHost.getJID());
  304.         return response;
  305.     }

  307.     /**
  308.      * Increments the connection failure counter by one for the given address.
  309.      * 
  310.      * @param address the address the connection failure counter should be increased
  311.      */
  312.     private void incrementConnectionFailures(String address) {
  313.         Integer count = ADDRESS_BLACKLIST.get(address);
  314.         ADDRESS_BLACKLIST.put(address, count == null ? 1 : count + 1);
  315.     }

  317.     /**
  318.      * Returns how often the connection to the given address failed.
  319.      * 
  320.      * @param address the address
  321.      * @return number of connection failures
  322.      */
  323.     private int getConnectionFailures(String address) {
  324.         Integer count = ADDRESS_BLACKLIST.get(address);
  325.         return count != null ? count : 0;
  326.     }

  328. }
Created with JaCoCo 0.7.4.201502262128