Socks5BytestreamManager.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.ArrayList;
  22. import java.util.Collections;
  23. import java.util.HashMap;
  24. import java.util.HashSet;
  25. import java.util.LinkedList;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.Random;
  29. import java.util.Set;
  30. import java.util.concurrent.ConcurrentHashMap;
  31. import java.util.concurrent.TimeoutException;

  33. import org.jivesoftware.smack.AbstractConnectionClosedListener;
  34. import org.jivesoftware.smack.SmackException;
  35. import org.jivesoftware.smack.SmackException.NoResponseException;
  36. import org.jivesoftware.smack.SmackException.FeatureNotSupportedException;
  37. import org.jivesoftware.smack.SmackException.NotConnectedException;
  38. import org.jivesoftware.smack.XMPPConnection;
  39. import org.jivesoftware.smack.ConnectionCreationListener;
  40. import org.jivesoftware.smack.XMPPConnectionRegistry;
  41. import org.jivesoftware.smack.XMPPException;
  42. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  43. import org.jivesoftware.smack.packet.IQ;
  44. import org.jivesoftware.smack.packet.Stanza;
  45. import org.jivesoftware.smack.packet.XMPPError;
  46. import org.jivesoftware.smackx.bytestreams.BytestreamListener;
  47. import org.jivesoftware.smackx.bytestreams.BytestreamManager;
  48. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream;
  49. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHost;
  50. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream.StreamHostUsed;
  51. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  52. import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
  53. import org.jivesoftware.smackx.disco.packet.DiscoverItems;
  54. import org.jivesoftware.smackx.disco.packet.DiscoverItems.Item;
  55. import org.jivesoftware.smackx.filetransfer.FileTransferManager;
  56. import org.jxmpp.jid.Jid;

  58. /**
  59.  * The Socks5BytestreamManager class handles establishing SOCKS5 Bytestreams as specified in the <a
  60.  * href="http://xmpp.org/extensions/xep-0065.html">XEP-0065</a>.
  61.  * <p>
  62.  * A SOCKS5 Bytestream is negotiated partly over the XMPP XML stream and partly over a separate
  63.  * socket. The actual transfer though takes place over a separately created socket.
  64.  * <p>
  65.  * A SOCKS5 Bytestream generally has three parties, the initiator, the target, and the stream host.
  66.  * The stream host is a specialized SOCKS5 proxy setup on a server, or, the initiator can act as the
  67.  * stream host.
  68.  * <p>
  69.  * To establish a SOCKS5 Bytestream invoke the {@link #establishSession(Jid)} method. This will
  70.  * negotiate a SOCKS5 Bytestream with the given target JID and return a socket.
  71.  * <p>
  72.  * If a session ID for the SOCKS5 Bytestream was already negotiated (e.g. while negotiating a file
  73.  * transfer) invoke {@link #establishSession(Jid, String)}.
  74.  * <p>
  75.  * To handle incoming SOCKS5 Bytestream requests add an {@link Socks5BytestreamListener} to the
  76.  * manager. There are two ways to add this listener. If you want to be informed about incoming
  77.  * SOCKS5 Bytestreams from a specific user add the listener by invoking
  78.  * {@link #addIncomingBytestreamListener(BytestreamListener, Jid)}. If the listener should
  79.  * respond to all SOCKS5 Bytestream requests invoke
  80.  * {@link #addIncomingBytestreamListener(BytestreamListener)}.
  81.  * <p>
  82.  * Note that the registered {@link Socks5BytestreamListener} will NOT be notified on incoming Socks5
  83.  * bytestream requests sent in the context of <a
  84.  * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  85.  * {@link FileTransferManager})
  86.  * <p>
  87.  * If no {@link Socks5BytestreamListener}s are registered, all incoming SOCKS5 Bytestream requests
  88.  * will be rejected by returning a &lt;not-acceptable/&gt; error to the initiator.
  89.  * 
  90.  * @author Henning Staib
  91.  */
  92. public final class Socks5BytestreamManager implements BytestreamManager {

  94.     /*
  95.      * create a new Socks5BytestreamManager and register a shutdown listener on every established
  96.      * connection
  97.      */
  98.     static {
  99.         XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {

  101.             public void connectionCreated(final XMPPConnection connection) {
  102.                 // create the manager for this connection
  103.                 Socks5BytestreamManager.getBytestreamManager(connection);

  105.                 // register shutdown listener
  106.                 connection.addConnectionListener(new AbstractConnectionClosedListener() {

  108.                     @Override
  109.                     public void connectionTerminated() {
  110.                         Socks5BytestreamManager.getBytestreamManager(connection).disableService();
  111.                     }

  113.                     @Override
  114.                     public void reconnectionSuccessful() {
  115.                         // re-create the manager for this connection
  116.                         Socks5BytestreamManager.getBytestreamManager(connection);
  117.                     }

  119.                 });
  120.             }

  122.         });
  123.     }

  125.     /* prefix used to generate session IDs */
  126.     private static final String SESSION_ID_PREFIX = "js5_";

  128.     /* random generator to create session IDs */
  129.     private final static Random randomGenerator = new Random();

  131.     /* stores one Socks5BytestreamManager for each XMPP connection */
  132.     private final static Map<XMPPConnection, Socks5BytestreamManager> managers = new HashMap<XMPPConnection, Socks5BytestreamManager>();

  134.     /* XMPP connection */
  135.     private final XMPPConnection connection;

  137.     /*
  138.      * assigns a user to a listener that is informed if a bytestream request for this user is
  139.      * received
  140.      */
  141.     private final Map<Jid, BytestreamListener> userListeners = new ConcurrentHashMap<>();

  143.     /*
  144.      * list of listeners that respond to all bytestream requests if there are not user specific
  145.      * listeners for that request
  146.      */
  147.     private final List<BytestreamListener> allRequestListeners = Collections.synchronizedList(new LinkedList<BytestreamListener>());

  149.     /* listener that handles all incoming bytestream requests */
  150.     private final InitiationListener initiationListener;

  152.     /* timeout to wait for the response to the SOCKS5 Bytestream initialization request */
  153.     private int targetResponseTimeout = 10000;

  155.     /* timeout for connecting to the SOCKS5 proxy selected by the target */
  156.     private int proxyConnectionTimeout = 10000;

  158.     /* blacklist of errornous SOCKS5 proxies */
  159.     private final Set<Jid> proxyBlacklist = Collections.synchronizedSet(new HashSet<Jid>());

  161.     /* remember the last proxy that worked to prioritize it */
  162.     private Jid lastWorkingProxy;

  164.     /* flag to enable/disable prioritization of last working proxy */
  165.     private boolean proxyPrioritizationEnabled = true;

  167.     /*
  168.      * list containing session IDs of SOCKS5 Bytestream initialization packets that should be
  169.      * ignored by the InitiationListener
  170.      */
  171.     private List<String> ignoredBytestreamRequests = Collections.synchronizedList(new LinkedList<String>());

  173.     /**
  174.      * Returns the Socks5BytestreamManager to handle SOCKS5 Bytestreams for a given
  175.      * {@link XMPPConnection}.
  176.      * <p>
  177.      * If no manager exists a new is created and initialized.
  178.      * 
  179.      * @param connection the XMPP connection or <code>null</code> if given connection is
  180.      *        <code>null</code>
  181.      * @return the Socks5BytestreamManager for the given XMPP connection
  182.      */
  183.     public static synchronized Socks5BytestreamManager getBytestreamManager(XMPPConnection connection) {
  184.         if (connection == null) {
  185.             return null;
  186.         }
  187.         Socks5BytestreamManager manager = managers.get(connection);
  188.         if (manager == null) {
  189.             manager = new Socks5BytestreamManager(connection);
  190.             managers.put(connection, manager);
  191.             manager.activate();
  192.         }
  193.         return manager;
  194.     }

  196.     /**
  197.      * Private constructor.
  198.      * 
  199.      * @param connection the XMPP connection
  200.      */
  201.     private Socks5BytestreamManager(XMPPConnection connection) {
  202.         this.connection = connection;
  203.         this.initiationListener = new InitiationListener(this);
  204.     }

  206.     /**
  207.      * Adds BytestreamListener that is called for every incoming SOCKS5 Bytestream request unless
  208.      * there is a user specific BytestreamListener registered.
  209.      * <p>
  210.      * If no listeners are registered all SOCKS5 Bytestream request are rejected with a
  211.      * &lt;not-acceptable/&gt; error.
  212.      * <p>
  213.      * Note that the registered {@link BytestreamListener} will NOT be notified on incoming Socks5
  214.      * bytestream requests sent in the context of <a
  215.      * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  216.      * {@link FileTransferManager})
  217.      * 
  218.      * @param listener the listener to register
  219.      */
  220.     public void addIncomingBytestreamListener(BytestreamListener listener) {
  221.         this.allRequestListeners.add(listener);
  222.     }

  224.     /**
  225.      * Removes the given listener from the list of listeners for all incoming SOCKS5 Bytestream
  226.      * requests.
  227.      * 
  228.      * @param listener the listener to remove
  229.      */
  230.     public void removeIncomingBytestreamListener(BytestreamListener listener) {
  231.         this.allRequestListeners.remove(listener);
  232.     }

  234.     /**
  235.      * Adds BytestreamListener that is called for every incoming SOCKS5 Bytestream request from the
  236.      * given user.
  237.      * <p>
  238.      * Use this method if you are awaiting an incoming SOCKS5 Bytestream request from a specific
  239.      * user.
  240.      * <p>
  241.      * If no listeners are registered all SOCKS5 Bytestream request are rejected with a
  242.      * &lt;not-acceptable/&gt; error.
  243.      * <p>
  244.      * Note that the registered {@link BytestreamListener} will NOT be notified on incoming Socks5
  245.      * bytestream requests sent in the context of <a
  246.      * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  247.      * {@link FileTransferManager})
  248.      * 
  249.      * @param listener the listener to register
  250.      * @param initiatorJID the JID of the user that wants to establish a SOCKS5 Bytestream
  251.      */
  252.     public void addIncomingBytestreamListener(BytestreamListener listener, Jid initiatorJID) {
  253.         this.userListeners.put(initiatorJID, listener);
  254.     }

  256.     /**
  257.      * Removes the listener for the given user.
  258.      * 
  259.      * @param initiatorJID the JID of the user the listener should be removed
  260.      */
  261.     public void removeIncomingBytestreamListener(String initiatorJID) {
  262.         this.userListeners.remove(initiatorJID);
  263.     }

  265.     /**
  266.      * Use this method to ignore the next incoming SOCKS5 Bytestream request containing the given
  267.      * session ID. No listeners will be notified for this request and and no error will be returned
  268.      * to the initiator.
  269.      * <p>
  270.      * This method should be used if you are awaiting a SOCKS5 Bytestream request as a reply to
  271.      * another packet (e.g. file transfer).
  272.      * 
  273.      * @param sessionID to be ignored
  274.      */
  275.     public void ignoreBytestreamRequestOnce(String sessionID) {
  276.         this.ignoredBytestreamRequests.add(sessionID);
  277.     }

  279.     /**
  280.      * Disables the SOCKS5 Bytestream manager by removing the SOCKS5 Bytestream feature from the
  281.      * service discovery, disabling the listener for SOCKS5 Bytestream initiation requests and
  282.      * resetting its internal state, which includes removing this instance from the managers map.
  283.      * <p>
  284.      * To re-enable the SOCKS5 Bytestream feature invoke {@link #getBytestreamManager(XMPPConnection)}.
  285.      * Using the file transfer API will automatically re-enable the SOCKS5 Bytestream feature.
  286.      */
  287.     public synchronized void disableService() {

  289.         // remove initiation packet listener
  290.         connection.unregisterIQRequestHandler(initiationListener);

  292.         // shutdown threads
  293.         this.initiationListener.shutdown();

  295.         // clear listeners
  296.         this.allRequestListeners.clear();
  297.         this.userListeners.clear();

  299.         // reset internal state
  300.         this.lastWorkingProxy = null;
  301.         this.proxyBlacklist.clear();
  302.         this.ignoredBytestreamRequests.clear();

  304.         // remove manager from static managers map
  305.         managers.remove(this.connection);

  307.         // shutdown local SOCKS5 proxy if there are no more managers for other connections
  308.         if (managers.size() == 0) {
  309.             Socks5Proxy.getSocks5Proxy().stop();
  310.         }

  312.         // remove feature from service discovery
  313.         ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(this.connection);

  315.         // check if service discovery is not already disposed by connection shutdown
  316.         if (serviceDiscoveryManager != null) {
  317.             serviceDiscoveryManager.removeFeature(Bytestream.NAMESPACE);
  318.         }

  320.     }

  322.     /**
  323.      * Returns the timeout to wait for the response to the SOCKS5 Bytestream initialization request.
  324.      * Default is 10000ms.
  325.      * 
  326.      * @return the timeout to wait for the response to the SOCKS5 Bytestream initialization request
  327.      */
  328.     public int getTargetResponseTimeout() {
  329.         if (this.targetResponseTimeout <= 0) {
  330.             this.targetResponseTimeout = 10000;
  331.         }
  332.         return targetResponseTimeout;
  333.     }

  335.     /**
  336.      * Sets the timeout to wait for the response to the SOCKS5 Bytestream initialization request.
  337.      * Default is 10000ms.
  338.      * 
  339.      * @param targetResponseTimeout the timeout to set
  340.      */
  341.     public void setTargetResponseTimeout(int targetResponseTimeout) {
  342.         this.targetResponseTimeout = targetResponseTimeout;
  343.     }

  345.     /**
  346.      * Returns the timeout for connecting to the SOCKS5 proxy selected by the target. Default is
  347.      * 10000ms.
  348.      * 
  349.      * @return the timeout for connecting to the SOCKS5 proxy selected by the target
  350.      */
  351.     public int getProxyConnectionTimeout() {
  352.         if (this.proxyConnectionTimeout <= 0) {
  353.             this.proxyConnectionTimeout = 10000;
  354.         }
  355.         return proxyConnectionTimeout;
  356.     }

  358.     /**
  359.      * Sets the timeout for connecting to the SOCKS5 proxy selected by the target. Default is
  360.      * 10000ms.
  361.      * 
  362.      * @param proxyConnectionTimeout the timeout to set
  363.      */
  364.     public void setProxyConnectionTimeout(int proxyConnectionTimeout) {
  365.         this.proxyConnectionTimeout = proxyConnectionTimeout;
  366.     }

  368.     /**
  369.      * Returns if the prioritization of the last working SOCKS5 proxy on successive SOCKS5
  370.      * Bytestream connections is enabled. Default is <code>true</code>.
  371.      * 
  372.      * @return <code>true</code> if prioritization is enabled, <code>false</code> otherwise
  373.      */
  374.     public boolean isProxyPrioritizationEnabled() {
  375.         return proxyPrioritizationEnabled;
  376.     }

  378.     /**
  379.      * Enable/disable the prioritization of the last working SOCKS5 proxy on successive SOCKS5
  380.      * Bytestream connections.
  381.      * 
  382.      * @param proxyPrioritizationEnabled enable/disable the prioritization of the last working
  383.      *        SOCKS5 proxy
  384.      */
  385.     public void setProxyPrioritizationEnabled(boolean proxyPrioritizationEnabled) {
  386.         this.proxyPrioritizationEnabled = proxyPrioritizationEnabled;
  387.     }

  389.     /**
  390.      * Establishes a SOCKS5 Bytestream with the given user and returns the Socket to send/receive
  391.      * data to/from the user.
  392.      * <p>
  393.      * Use this method to establish SOCKS5 Bytestreams to users accepting all incoming Socks5
  394.      * bytestream requests since this method doesn't provide a way to tell the user something about
  395.      * the data to be sent.
  396.      * <p>
  397.      * To establish a SOCKS5 Bytestream after negotiation the kind of data to be sent (e.g. file
  398.      * transfer) use {@link #establishSession(Jid, String)}.
  399.      * 
  400.      * @param targetJID the JID of the user a SOCKS5 Bytestream should be established
  401.      * @return the Socket to send/receive data to/from the user
  402.      * @throws XMPPException if the user doesn't support or accept SOCKS5 Bytestreams, if no Socks5
  403.      *         Proxy could be found, if the user couldn't connect to any of the SOCKS5 Proxies
  404.      * @throws IOException if the bytestream could not be established
  405.      * @throws InterruptedException if the current thread was interrupted while waiting
  406.      * @throws SmackException if there was no response from the server.
  407.      */
  408.     public Socks5BytestreamSession establishSession(Jid targetJID) throws XMPPException,
  409.                     IOException, InterruptedException, SmackException {
  410.         String sessionID = getNextSessionID();
  411.         return establishSession(targetJID, sessionID);
  412.     }

  414.     /**
  415.      * Establishes a SOCKS5 Bytestream with the given user using the given session ID and returns
  416.      * the Socket to send/receive data to/from the user.
  417.      * 
  418.      * @param targetJID the JID of the user a SOCKS5 Bytestream should be established
  419.      * @param sessionID the session ID for the SOCKS5 Bytestream request
  420.      * @return the Socket to send/receive data to/from the user
  421.      * @throws IOException if the bytestream could not be established
  422.      * @throws InterruptedException if the current thread was interrupted while waiting
  423.      * @throws NoResponseException 
  424.      * @throws SmackException if the target does not support SOCKS5.
  425.      * @throws XMPPException 
  426.      */
  427.     public Socks5BytestreamSession establishSession(Jid targetJID, String sessionID)
  428.                     throws IOException, InterruptedException, NoResponseException, SmackException, XMPPException{

  430.         XMPPErrorException discoveryException = null;
  431.         // check if target supports SOCKS5 Bytestream
  432.         if (!supportsSocks5(targetJID)) {
  433.             throw new FeatureNotSupportedException("SOCKS5 Bytestream", targetJID);
  434.         }

  436.         List<Jid> proxies = new ArrayList<>();
  437.         // determine SOCKS5 proxies from XMPP-server
  438.         try {
  439.             proxies.addAll(determineProxies());
  440.         } catch (XMPPErrorException e) {
  441.             // don't abort here, just remember the exception thrown by determineProxies()
  442.             // determineStreamHostInfos() will at least add the local Socks5 proxy (if enabled)
  443.             discoveryException = e;
  444.         }

  446.         // determine address and port of each proxy
  447.         List<StreamHost> streamHosts = determineStreamHostInfos(proxies);

  449.         if (streamHosts.isEmpty()) {
  450.             if (discoveryException != null) {
  451.                 throw discoveryException;
  452.             } else {
  453.                 throw new SmackException("no SOCKS5 proxies available");
  454.             }
  455.         }

  457.         // compute digest
  458.         String digest = Socks5Utils.createDigest(sessionID, this.connection.getUser(), targetJID);

  460.         // prioritize last working SOCKS5 proxy if exists
  461.         if (this.proxyPrioritizationEnabled && this.lastWorkingProxy != null) {
  462.             StreamHost selectedStreamHost = null;
  463.             for (StreamHost streamHost : streamHosts) {
  464.                 if (streamHost.getJID().equals(this.lastWorkingProxy)) {
  465.                     selectedStreamHost = streamHost;
  466.                     break;
  467.                 }
  468.             }
  469.             if (selectedStreamHost != null) {
  470.                 streamHosts.remove(selectedStreamHost);
  471.                 streamHosts.add(0, selectedStreamHost);
  472.             }

  474.         }

  476.         Socks5Proxy socks5Proxy = Socks5Proxy.getSocks5Proxy();
  477.         try {

  479.             // add transfer digest to local proxy to make transfer valid
  480.             socks5Proxy.addTransfer(digest);

  482.             // create initiation packet
  483.             Bytestream initiation = createBytestreamInitiation(sessionID, targetJID, streamHosts);

  485.             // send initiation packet
  486.             Stanza response = connection.createPacketCollectorAndSend(initiation).nextResultOrThrow(
  487.                             getTargetResponseTimeout());

  489.             // extract used stream host from response
  490.             StreamHostUsed streamHostUsed = ((Bytestream) response).getUsedHost();
  491.             StreamHost usedStreamHost = initiation.getStreamHost(streamHostUsed.getJID());

  493.             if (usedStreamHost == null) {
  494.                 throw new SmackException("Remote user responded with unknown host");
  495.             }

  497.             // build SOCKS5 client
  498.             Socks5Client socks5Client = new Socks5ClientForInitiator(usedStreamHost, digest,
  499.                             this.connection, sessionID, targetJID);

  501.             // establish connection to proxy
  502.             Socket socket = socks5Client.getSocket(getProxyConnectionTimeout());

  504.             // remember last working SOCKS5 proxy to prioritize it for next request
  505.             this.lastWorkingProxy = usedStreamHost.getJID();

  507.             // negotiation successful, return the output stream
  508.             return new Socks5BytestreamSession(socket, usedStreamHost.getJID().equals(
  509.                             this.connection.getUser()));

  511.         }
  512.         catch (TimeoutException e) {
  513.             throw new IOException("Timeout while connecting to SOCKS5 proxy");
  514.         }
  515.         finally {

  517.             // remove transfer digest if output stream is returned or an exception
  518.             // occurred
  519.             socks5Proxy.removeTransfer(digest);

  521.         }
  522.     }

  524.     /**
  525.      * Returns <code>true</code> if the given target JID supports feature SOCKS5 Bytestream.
  526.      * 
  527.      * @param targetJID the target JID
  528.      * @return <code>true</code> if the given target JID supports feature SOCKS5 Bytestream
  529.      *         otherwise <code>false</code>
  530.      * @throws XMPPErrorException 
  531.      * @throws NoResponseException 
  532.      * @throws NotConnectedException 
  533.      * @throws InterruptedException 
  534.      */
  535.     private boolean supportsSocks5(Jid targetJID) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  536.         return ServiceDiscoveryManager.getInstanceFor(connection).supportsFeature(targetJID, Bytestream.NAMESPACE);
  537.     }

  539.     /**
  540.      * Returns a list of JIDs of SOCKS5 proxies by querying the XMPP server. The SOCKS5 proxies are
  541.      * in the same order as returned by the XMPP server.
  542.      * 
  543.      * @return list of JIDs of SOCKS5 proxies
  544.      * @throws XMPPErrorException if there was an error querying the XMPP server for SOCKS5 proxies
  545.      * @throws NoResponseException if there was no response from the server.
  546.      * @throws NotConnectedException 
  547.      * @throws InterruptedException 
  548.      */
  549.     private List<Jid> determineProxies() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  550.         ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(this.connection);

  552.         List<Jid> proxies = new ArrayList<>();

  554.         // get all items from XMPP server
  555.         DiscoverItems discoverItems = serviceDiscoveryManager.discoverItems(this.connection.getServiceName());

  557.         // query all items if they are SOCKS5 proxies
  558.         for (Item item : discoverItems.getItems()) {
  559.             // skip blacklisted servers
  560.             if (this.proxyBlacklist.contains(item.getEntityID())) {
  561.                 continue;
  562.             }

  564.             DiscoverInfo proxyInfo;
  565.             try {
  566.                 proxyInfo = serviceDiscoveryManager.discoverInfo(item.getEntityID());
  567.             }
  568.             catch (NoResponseException|XMPPErrorException e) {
  569.                 // blacklist errornous server
  570.                 proxyBlacklist.add(item.getEntityID());
  571.                 continue;
  572.             }

  574.             if (proxyInfo.hasIdentity("proxy", "bytestreams")) {
  575.                 proxies.add(item.getEntityID());
  576.             } else {
  577.                 /*
  578.                  * server is not a SOCKS5 proxy, blacklist server to skip next time a Socks5
  579.                  * bytestream should be established
  580.                  */
  581.                 this.proxyBlacklist.add(item.getEntityID());
  582.             }
  583.         }

  585.         return proxies;
  586.     }

  588.     /**
  589.      * Returns a list of stream hosts containing the IP address an the port for the given list of
  590.      * SOCKS5 proxy JIDs. The order of the returned list is the same as the given list of JIDs
  591.      * excluding all SOCKS5 proxies who's network settings could not be determined. If a local
  592.      * SOCKS5 proxy is running it will be the first item in the list returned.
  593.      * 
  594.      * @param proxies a list of SOCKS5 proxy JIDs
  595.      * @return a list of stream hosts containing the IP address an the port
  596.      */
  597.     private List<StreamHost> determineStreamHostInfos(List<Jid> proxies) {
  598.         List<StreamHost> streamHosts = new ArrayList<StreamHost>();

  600.         // add local proxy on first position if exists
  601.         List<StreamHost> localProxies = getLocalStreamHost();
  602.         if (localProxies != null) {
  603.             streamHosts.addAll(localProxies);
  604.         }

  606.         // query SOCKS5 proxies for network settings
  607.         for (Jid proxy : proxies) {
  608.             Bytestream streamHostRequest = createStreamHostRequest(proxy);
  609.             try {
  610.                 Bytestream response = (Bytestream) connection.createPacketCollectorAndSend(
  611.                                 streamHostRequest).nextResultOrThrow();
  612.                 streamHosts.addAll(response.getStreamHosts());
  613.             }
  614.             catch (Exception e) {
  615.                 // blacklist errornous proxies
  616.                 this.proxyBlacklist.add(proxy);
  617.             }
  618.         }

  620.         return streamHosts;
  621.     }

  623.     /**
  624.      * Returns a IQ packet to query a SOCKS5 proxy its network settings.
  625.      * 
  626.      * @param proxy the proxy to query
  627.      * @return IQ packet to query a SOCKS5 proxy its network settings
  628.      */
  629.     private Bytestream createStreamHostRequest(Jid proxy) {
  630.         Bytestream request = new Bytestream();
  631.         request.setType(IQ.Type.get);
  632.         request.setTo(proxy);
  633.         return request;
  634.     }

  636.     /**
  637.      * Returns the stream host information of the local SOCKS5 proxy containing the IP address and
  638.      * the port or null if local SOCKS5 proxy is not running.
  639.      * 
  640.      * @return the stream host information of the local SOCKS5 proxy or null if local SOCKS5 proxy
  641.      *         is not running
  642.      */
  643.     private List<StreamHost> getLocalStreamHost() {

  645.         // get local proxy singleton
  646.         Socks5Proxy socks5Server = Socks5Proxy.getSocks5Proxy();

  648.         if (!socks5Server.isRunning()) {
  649.             // server is not running
  650.             return null;
  651.         }
  652.         List<String> addresses = socks5Server.getLocalAddresses();
  653.         if (addresses.isEmpty()) {
  654.             // local address could not be determined
  655.             return null;
  656.         }
  657.         final int port = socks5Server.getPort();

  659.         List<StreamHost> streamHosts = new ArrayList<StreamHost>();
  660.         outerloop: for (String address : addresses) {
  661.             // Prevent loopback addresses from appearing as streamhost
  662.             final String[] loopbackAddresses = { "127.0.0.1", "0:0:0:0:0:0:0:1", "::1" };
  663.             for (String loopbackAddress : loopbackAddresses) {
  664.                 // Use 'startsWith' here since IPv6 addresses may have scope ID,
  665.                 // ie. the part after the '%' sign.
  666.                 if (address.startsWith(loopbackAddress)) {
  667.                     continue outerloop;
  668.                 }
  669.             }
  670.             streamHosts.add(new StreamHost(connection.getUser(), address, port));
  671.         }
  672.         return streamHosts;
  673.     }

  675.     /**
  676.      * Returns a SOCKS5 Bytestream initialization request packet with the given session ID
  677.      * containing the given stream hosts for the given target JID.
  678.      * 
  679.      * @param sessionID the session ID for the SOCKS5 Bytestream
  680.      * @param targetJID the target JID of SOCKS5 Bytestream request
  681.      * @param streamHosts a list of SOCKS5 proxies the target should connect to
  682.      * @return a SOCKS5 Bytestream initialization request packet
  683.      */
  684.     private Bytestream createBytestreamInitiation(String sessionID, Jid targetJID,
  685.                     List<StreamHost> streamHosts) {
  686.         Bytestream initiation = new Bytestream(sessionID);

  688.         // add all stream hosts
  689.         for (StreamHost streamHost : streamHosts) {
  690.             initiation.addStreamHost(streamHost);
  691.         }

  693.         initiation.setType(IQ.Type.set);
  694.         initiation.setTo(targetJID);

  696.         return initiation;
  697.     }

  699.     /**
  700.      * Responses to the given packet's sender with an XMPP error that a SOCKS5 Bytestream is not
  701.      * accepted.
  702.      * <p>
  703.      * Specified in XEP-65 5.3.1 (Example 13)
  704.      * </p>
  705.      * 
  706.      * @param packet Packet that should be answered with a not-acceptable error
  707.      * @throws NotConnectedException 
  708.      * @throws InterruptedException 
  709.      */
  710.     protected void replyRejectPacket(IQ packet) throws NotConnectedException, InterruptedException {
  711.         XMPPError xmppError = new XMPPError(XMPPError.Condition.not_acceptable);
  712.         IQ errorIQ = IQ.createErrorResponse(packet, xmppError);
  713.         this.connection.sendStanza(errorIQ);
  714.     }

  716.     /**
  717.      * Activates the Socks5BytestreamManager by registering the SOCKS5 Bytestream initialization
  718.      * listener and enabling the SOCKS5 Bytestream feature.
  719.      */
  720.     private void activate() {
  721.         // register bytestream initiation packet listener
  722.         connection.registerIQRequestHandler(initiationListener);

  724.         // enable SOCKS5 feature
  725.         enableService();
  726.     }

  728.     /**
  729.      * Adds the SOCKS5 Bytestream feature to the service discovery.
  730.      */
  731.     private void enableService() {
  732.         ServiceDiscoveryManager manager = ServiceDiscoveryManager.getInstanceFor(this.connection);
  733.         manager.addFeature(Bytestream.NAMESPACE);
  734.     }

  736.     /**
  737.      * Returns a new unique session ID.
  738.      * 
  739.      * @return a new unique session ID
  740.      */
  741.     private String getNextSessionID() {
  742.         StringBuilder buffer = new StringBuilder();
  743.         buffer.append(SESSION_ID_PREFIX);
  744.         buffer.append(Math.abs(randomGenerator.nextLong()));
  745.         return buffer.toString();
  746.     }

  748.     /**
  749.      * Returns the XMPP connection.
  750.      * 
  751.      * @return the XMPP connection
  752.      */
  753.     protected XMPPConnection getConnection() {
  754.         return this.connection;
  755.     }

  757.     /**
  758.      * Returns the {@link BytestreamListener} that should be informed if a SOCKS5 Bytestream request
  759.      * from the given initiator JID is received.
  760.      * 
  761.      * @param initiator the initiator's JID
  762.      * @return the listener
  763.      */
  764.     protected BytestreamListener getUserListener(Jid initiator) {
  765.         return this.userListeners.get(initiator);
  766.     }

  768.     /**
  769.      * Returns a list of {@link BytestreamListener} that are informed if there are no listeners for
  770.      * a specific initiator.
  771.      * 
  772.      * @return list of listeners
  773.      */
  774.     protected List<BytestreamListener> getAllRequestListeners() {
  775.         return this.allRequestListeners;
  776.     }

  778.     /**
  779.      * Returns the list of session IDs that should be ignored by the InitialtionListener
  780.      * 
  781.      * @return list of session IDs
  782.      */
  783.     protected List<String> getIgnoredBytestreamRequests() {
  784.         return ignoredBytestreamRequests;
  785.     }

  787. }
Created with JaCoCo 0.7.4.201502262128