InBandBytestreamManager.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.ibb;

  19. import java.util.Collections;
  20. import java.util.HashMap;
  21. import java.util.LinkedList;
  22. import java.util.List;
  23. import java.util.Map;
  24. import java.util.Random;
  25. import java.util.concurrent.ConcurrentHashMap;

  27. import org.jivesoftware.smack.AbstractConnectionClosedListener;
  28. import org.jivesoftware.smack.ConnectionCreationListener;
  29. import org.jivesoftware.smack.SmackException;
  30. import org.jivesoftware.smack.SmackException.NoResponseException;
  31. import org.jivesoftware.smack.SmackException.NotConnectedException;
  32. import org.jivesoftware.smack.XMPPConnection;
  33. import org.jivesoftware.smack.XMPPConnectionRegistry;
  34. import org.jivesoftware.smack.XMPPException;
  35. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  36. import org.jivesoftware.smack.packet.IQ;
  37. import org.jivesoftware.smack.packet.XMPPError;
  38. import org.jivesoftware.smackx.bytestreams.BytestreamListener;
  39. import org.jivesoftware.smackx.bytestreams.BytestreamManager;
  40. import org.jivesoftware.smackx.bytestreams.ibb.packet.Open;
  41. import org.jivesoftware.smackx.filetransfer.FileTransferManager;
  42. import org.jxmpp.jid.Jid;

  44. /**
  45.  * The InBandBytestreamManager class handles establishing In-Band Bytestreams as specified in the <a
  46.  * href="http://xmpp.org/extensions/xep-0047.html">XEP-0047</a>.
  47.  * <p>
  48.  * The In-Band Bytestreams (IBB) enables two entities to establish a virtual bytestream over which
  49.  * they can exchange Base64-encoded chunks of data over XMPP itself. It is the fall-back mechanism
  50.  * in case the Socks5 bytestream method of transferring data is not available.
  51.  * <p>
  52.  * There are two ways to send data over an In-Band Bytestream. It could either use IQ stanzas to
  53.  * send data packets or message stanzas. If IQ stanzas are used every data packet is acknowledged by
  54.  * the receiver. This is the recommended way to avoid possible rate-limiting penalties. Message
  55.  * stanzas are not acknowledged because most XMPP server implementation don't support stanza
  56.  * flow-control method like <a href="http://xmpp.org/extensions/xep-0079.html">Advanced Message
  57.  * Processing</a>. To set the stanza that should be used invoke {@link #setStanza(StanzaType)}.
  58.  * <p>
  59.  * To establish an In-Band Bytestream invoke the {@link #establishSession(Jid)} method. This will
  60.  * negotiate an in-band bytestream with the given target JID and return a session.
  61.  * <p>
  62.  * If a session ID for the In-Band Bytestream was already negotiated (e.g. while negotiating a file
  63.  * transfer) invoke {@link #establishSession(Jid, String)}.
  64.  * <p>
  65.  * To handle incoming In-Band Bytestream requests add an {@link InBandBytestreamListener} to the
  66.  * manager. There are two ways to add this listener. If you want to be informed about incoming
  67.  * In-Band Bytestreams from a specific user add the listener by invoking
  68.  * {@link #addIncomingBytestreamListener(BytestreamListener, Jid)}. If the listener should
  69.  * respond to all In-Band Bytestream requests invoke
  70.  * {@link #addIncomingBytestreamListener(BytestreamListener)}.
  71.  * <p>
  72.  * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming
  73.  * In-Band bytestream requests sent in the context of <a
  74.  * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  75.  * {@link FileTransferManager})
  76.  * <p>
  77.  * If no {@link InBandBytestreamListener}s are registered, all incoming In-Band bytestream requests
  78.  * will be rejected by returning a &lt;not-acceptable/&gt; error to the initiator.
  79.  * 
  80.  * @author Henning Staib
  81.  */
  82. public class InBandBytestreamManager implements BytestreamManager {

  84.     /**
  85.      * Stanzas that can be used to encapsulate In-Band Bytestream data packets.
  86.      */
  87.     public enum StanzaType {

  89.         /**
  90.          * IQ stanza.
  91.          */
  92.         IQ,

  94.         /**
  95.          * Message stanza.
  96.          */
  97.         MESSAGE
  98.     }

  100.     /*
  101.      * create a new InBandBytestreamManager and register its shutdown listener on every established
  102.      * connection
  103.      */
  104.     static {
  105.         XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
  106.             public void connectionCreated(final XMPPConnection connection) {
  107.                 // create the manager for this connection
  108.                 InBandBytestreamManager.getByteStreamManager(connection);

  110.                 // register shutdown listener
  111.                 connection.addConnectionListener(new AbstractConnectionClosedListener() {

  113.                     @Override
  114.                     public void connectionTerminated() {
  115.                         InBandBytestreamManager.getByteStreamManager(connection).disableService();
  116.                     }

  118.                     @Override
  119.                     public void reconnectionSuccessful() {
  120.                         // re-create the manager for this connection
  121.                         InBandBytestreamManager.getByteStreamManager(connection);
  122.                     }

  124.                 });

  126.             }
  127.         });
  128.     }

  130.     /**
  131.      * Maximum block size that is allowed for In-Band Bytestreams
  132.      */
  133.     public static final int MAXIMUM_BLOCK_SIZE = 65535;

  135.     /* prefix used to generate session IDs */
  136.     private static final String SESSION_ID_PREFIX = "jibb_";

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

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

  144.     /* XMPP connection */
  145.     private final XMPPConnection connection;

  147.     /*
  148.      * assigns a user to a listener that is informed if an In-Band Bytestream request for this user
  149.      * is received
  150.      */
  151.     private final Map<Jid, BytestreamListener> userListeners = new ConcurrentHashMap<>();

  153.     /*
  154.      * list of listeners that respond to all In-Band Bytestream requests if there are no user
  155.      * specific listeners for that request
  156.      */
  157.     private final List<BytestreamListener> allRequestListeners = Collections.synchronizedList(new LinkedList<BytestreamListener>());

  159.     /* listener that handles all incoming In-Band Bytestream requests */
  160.     private final InitiationListener initiationListener;

  162.     /* listener that handles all incoming In-Band Bytestream IQ data packets */
  163.     private final DataListener dataListener;

  165.     /* listener that handles all incoming In-Band Bytestream close requests */
  166.     private final CloseListener closeListener;

  168.     /* assigns a session ID to the In-Band Bytestream session */
  169.     private final Map<String, InBandBytestreamSession> sessions = new ConcurrentHashMap<String, InBandBytestreamSession>();

  171.     /* block size used for new In-Band Bytestreams */
  172.     private int defaultBlockSize = 4096;

  174.     /* maximum block size allowed for this connection */
  175.     private int maximumBlockSize = MAXIMUM_BLOCK_SIZE;

  177.     /* the stanza used to send data packets */
  178.     private StanzaType stanza = StanzaType.IQ;

  180.     /*
  181.      * list containing session IDs of In-Band Bytestream open packets that should be ignored by the
  182.      * InitiationListener
  183.      */
  184.     private List<String> ignoredBytestreamRequests = Collections.synchronizedList(new LinkedList<String>());

  186.     /**
  187.      * Returns the InBandBytestreamManager to handle In-Band Bytestreams for a given
  188.      * {@link XMPPConnection}.
  189.      * 
  190.      * @param connection the XMPP connection
  191.      * @return the InBandBytestreamManager for the given XMPP connection
  192.      */
  193.     public static synchronized InBandBytestreamManager getByteStreamManager(XMPPConnection connection) {
  194.         if (connection == null)
  195.             return null;
  196.         InBandBytestreamManager manager = managers.get(connection);
  197.         if (manager == null) {
  198.             manager = new InBandBytestreamManager(connection);
  199.             managers.put(connection, manager);
  200.         }
  201.         return manager;
  202.     }

  204.     /**
  205.      * Constructor.
  206.      * 
  207.      * @param connection the XMPP connection
  208.      */
  209.     private InBandBytestreamManager(XMPPConnection connection) {
  210.         this.connection = connection;

  212.         // register bytestream open packet listener
  213.         this.initiationListener = new InitiationListener(this);
  214.         connection.registerIQRequestHandler(initiationListener);

  216.         // register bytestream data packet listener
  217.         this.dataListener = new DataListener(this);
  218.         connection.registerIQRequestHandler(dataListener);

  220.         // register bytestream close packet listener
  221.         this.closeListener = new CloseListener(this);
  222.         connection.registerIQRequestHandler(closeListener);
  223.     }

  225.     /**
  226.      * Adds InBandBytestreamListener that is called for every incoming in-band bytestream request
  227.      * unless there is a user specific InBandBytestreamListener registered.
  228.      * <p>
  229.      * If no listeners are registered all In-Band Bytestream request are rejected with a
  230.      * &lt;not-acceptable/&gt; error.
  231.      * <p>
  232.      * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming
  233.      * Socks5 bytestream requests sent in the context of <a
  234.      * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  235.      * {@link FileTransferManager})
  236.      * 
  237.      * @param listener the listener to register
  238.      */
  239.     public void addIncomingBytestreamListener(BytestreamListener listener) {
  240.         this.allRequestListeners.add(listener);
  241.     }

  243.     /**
  244.      * Removes the given listener from the list of listeners for all incoming In-Band Bytestream
  245.      * requests.
  246.      * 
  247.      * @param listener the listener to remove
  248.      */
  249.     public void removeIncomingBytestreamListener(BytestreamListener listener) {
  250.         this.allRequestListeners.remove(listener);
  251.     }

  253.     /**
  254.      * Adds InBandBytestreamListener that is called for every incoming in-band bytestream request
  255.      * from the given user.
  256.      * <p>
  257.      * Use this method if you are awaiting an incoming Socks5 bytestream request from a specific
  258.      * user.
  259.      * <p>
  260.      * If no listeners are registered all In-Band Bytestream request are rejected with a
  261.      * &lt;not-acceptable/&gt; error.
  262.      * <p>
  263.      * Note that the registered {@link InBandBytestreamListener} will NOT be notified on incoming
  264.      * Socks5 bytestream requests sent in the context of <a
  265.      * href="http://xmpp.org/extensions/xep-0096.html">XEP-0096</a> file transfer. (See
  266.      * {@link FileTransferManager})
  267.      * 
  268.      * @param listener the listener to register
  269.      * @param initiatorJID the JID of the user that wants to establish an In-Band Bytestream
  270.      */
  271.     public void addIncomingBytestreamListener(BytestreamListener listener, Jid initiatorJID) {
  272.         this.userListeners.put(initiatorJID, listener);
  273.     }

  275.     /**
  276.      * Removes the listener for the given user.
  277.      * 
  278.      * @param initiatorJID the JID of the user the listener should be removed
  279.      */
  280.     public void removeIncomingBytestreamListener(String initiatorJID) {
  281.         this.userListeners.remove(initiatorJID);
  282.     }

  284.     /**
  285.      * Use this method to ignore the next incoming In-Band Bytestream request containing the given
  286.      * session ID. No listeners will be notified for this request and and no error will be returned
  287.      * to the initiator.
  288.      * <p>
  289.      * This method should be used if you are awaiting an In-Band Bytestream request as a reply to
  290.      * another packet (e.g. file transfer).
  291.      * 
  292.      * @param sessionID to be ignored
  293.      */
  294.     public void ignoreBytestreamRequestOnce(String sessionID) {
  295.         this.ignoredBytestreamRequests.add(sessionID);
  296.     }

  298.     /**
  299.      * Returns the default block size that is used for all outgoing in-band bytestreams for this
  300.      * connection.
  301.      * <p>
  302.      * The recommended default block size is 4096 bytes. See <a
  303.      * href="http://xmpp.org/extensions/xep-0047.html#usage">XEP-0047</a> Section 5.
  304.      * 
  305.      * @return the default block size
  306.      */
  307.     public int getDefaultBlockSize() {
  308.         return defaultBlockSize;
  309.     }

  311.     /**
  312.      * Sets the default block size that is used for all outgoing in-band bytestreams for this
  313.      * connection.
  314.      * <p>
  315.      * The default block size must be between 1 and 65535 bytes. The recommended default block size
  316.      * is 4096 bytes. See <a href="http://xmpp.org/extensions/xep-0047.html#usage">XEP-0047</a>
  317.      * Section 5.
  318.      * 
  319.      * @param defaultBlockSize the default block size to set
  320.      */
  321.     public void setDefaultBlockSize(int defaultBlockSize) {
  322.         if (defaultBlockSize <= 0 || defaultBlockSize > MAXIMUM_BLOCK_SIZE) {
  323.             throw new IllegalArgumentException("Default block size must be between 1 and "
  324.                             + MAXIMUM_BLOCK_SIZE);
  325.         }
  326.         this.defaultBlockSize = defaultBlockSize;
  327.     }

  329.     /**
  330.      * Returns the maximum block size that is allowed for In-Band Bytestreams for this connection.
  331.      * <p>
  332.      * Incoming In-Band Bytestream open request will be rejected with an
  333.      * &lt;resource-constraint/&gt; error if the block size is greater then the maximum allowed
  334.      * block size.
  335.      * <p>
  336.      * The default maximum block size is 65535 bytes.
  337.      * 
  338.      * @return the maximum block size
  339.      */
  340.     public int getMaximumBlockSize() {
  341.         return maximumBlockSize;
  342.     }

  344.     /**
  345.      * Sets the maximum block size that is allowed for In-Band Bytestreams for this connection.
  346.      * <p>
  347.      * The maximum block size must be between 1 and 65535 bytes.
  348.      * <p>
  349.      * Incoming In-Band Bytestream open request will be rejected with an
  350.      * &lt;resource-constraint/&gt; error if the block size is greater then the maximum allowed
  351.      * block size.
  352.      * 
  353.      * @param maximumBlockSize the maximum block size to set
  354.      */
  355.     public void setMaximumBlockSize(int maximumBlockSize) {
  356.         if (maximumBlockSize <= 0 || maximumBlockSize > MAXIMUM_BLOCK_SIZE) {
  357.             throw new IllegalArgumentException("Maximum block size must be between 1 and "
  358.                             + MAXIMUM_BLOCK_SIZE);
  359.         }
  360.         this.maximumBlockSize = maximumBlockSize;
  361.     }

  363.     /**
  364.      * Returns the stanza used to send data packets.
  365.      * <p>
  366.      * Default is {@link StanzaType#IQ}. See <a
  367.      * href="http://xmpp.org/extensions/xep-0047.html#message">XEP-0047</a> Section 4.
  368.      * 
  369.      * @return the stanza used to send data packets
  370.      */
  371.     public StanzaType getStanza() {
  372.         return stanza;
  373.     }

  375.     /**
  376.      * Sets the stanza used to send data packets.
  377.      * <p>
  378.      * The use of {@link StanzaType#IQ} is recommended. See <a
  379.      * href="http://xmpp.org/extensions/xep-0047.html#message">XEP-0047</a> Section 4.
  380.      * 
  381.      * @param stanza the stanza to set
  382.      */
  383.     public void setStanza(StanzaType stanza) {
  384.         this.stanza = stanza;
  385.     }

  387.     /**
  388.      * Establishes an In-Band Bytestream with the given user and returns the session to send/receive
  389.      * data to/from the user.
  390.      * <p>
  391.      * Use this method to establish In-Band Bytestreams to users accepting all incoming In-Band
  392.      * Bytestream requests since this method doesn't provide a way to tell the user something about
  393.      * the data to be sent.
  394.      * <p>
  395.      * To establish an In-Band Bytestream after negotiation the kind of data to be sent (e.g. file
  396.      * transfer) use {@link #establishSession(Jid, String)}.
  397.      * 
  398.      * @param targetJID the JID of the user an In-Band Bytestream should be established
  399.      * @return the session to send/receive data to/from the user
  400.      * @throws XMPPException if the user doesn't support or accept in-band bytestreams, or if the
  401.      *         user prefers smaller block sizes
  402.      * @throws SmackException if there was no response from the server.
  403.      * @throws InterruptedException 
  404.      */
  405.     public InBandBytestreamSession establishSession(Jid targetJID) throws XMPPException, SmackException, InterruptedException {
  406.         String sessionID = getNextSessionID();
  407.         return establishSession(targetJID, sessionID);
  408.     }

  410.     /**
  411.      * Establishes an In-Band Bytestream with the given user using the given session ID and returns
  412.      * the session to send/receive data to/from the user.
  413.      * 
  414.      * @param targetJID the JID of the user an In-Band Bytestream should be established
  415.      * @param sessionID the session ID for the In-Band Bytestream request
  416.      * @return the session to send/receive data to/from the user
  417.      * @throws XMPPErrorException if the user doesn't support or accept in-band bytestreams, or if the
  418.      *         user prefers smaller block sizes
  419.      * @throws NoResponseException if there was no response from the server.
  420.      * @throws NotConnectedException 
  421.      * @throws InterruptedException 
  422.      */
  423.     public InBandBytestreamSession establishSession(Jid targetJID, String sessionID)
  424.                     throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  425.         Open byteStreamRequest = new Open(sessionID, this.defaultBlockSize, this.stanza);
  426.         byteStreamRequest.setTo(targetJID);

  428.         // sending packet will throw exception on timeout or error reply
  429.         connection.createPacketCollectorAndSend(byteStreamRequest).nextResultOrThrow();

  431.         InBandBytestreamSession inBandBytestreamSession = new InBandBytestreamSession(
  432.                         this.connection, byteStreamRequest, targetJID);
  433.         this.sessions.put(sessionID, inBandBytestreamSession);

  435.         return inBandBytestreamSession;
  436.     }

  438.     /**
  439.      * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream is
  440.      * not accepted.
  441.      * 
  442.      * @param request IQ packet that should be answered with a not-acceptable error
  443.      * @throws NotConnectedException 
  444.      * @throws InterruptedException 
  445.      */
  446.     protected void replyRejectPacket(IQ request) throws NotConnectedException, InterruptedException {
  447.         XMPPError xmppError = new XMPPError(XMPPError.Condition.not_acceptable);
  448.         IQ error = IQ.createErrorResponse(request, xmppError);
  449.         this.connection.sendStanza(error);
  450.     }

  452.     /**
  453.      * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream open
  454.      * request is rejected because its block size is greater than the maximum allowed block size.
  455.      * 
  456.      * @param request IQ packet that should be answered with a resource-constraint error
  457.      * @throws NotConnectedException 
  458.      * @throws InterruptedException 
  459.      */
  460.     protected void replyResourceConstraintPacket(IQ request) throws NotConnectedException, InterruptedException {
  461.         XMPPError xmppError = new XMPPError(XMPPError.Condition.resource_constraint);
  462.         IQ error = IQ.createErrorResponse(request, xmppError);
  463.         this.connection.sendStanza(error);
  464.     }

  466.     /**
  467.      * Responses to the given IQ packet's sender with an XMPP error that an In-Band Bytestream
  468.      * session could not be found.
  469.      * 
  470.      * @param request IQ packet that should be answered with a item-not-found error
  471.      * @throws NotConnectedException 
  472.      * @throws InterruptedException 
  473.      */
  474.     protected void replyItemNotFoundPacket(IQ request) throws NotConnectedException, InterruptedException {
  475.         XMPPError xmppError = new XMPPError(XMPPError.Condition.item_not_found);
  476.         IQ error = IQ.createErrorResponse(request, xmppError);
  477.         this.connection.sendStanza(error);
  478.     }

  480.     /**
  481.      * Returns a new unique session ID.
  482.      * 
  483.      * @return a new unique session ID
  484.      */
  485.     private String getNextSessionID() {
  486.         StringBuilder buffer = new StringBuilder();
  487.         buffer.append(SESSION_ID_PREFIX);
  488.         buffer.append(Math.abs(randomGenerator.nextLong()));
  489.         return buffer.toString();
  490.     }

  492.     /**
  493.      * Returns the XMPP connection.
  494.      * 
  495.      * @return the XMPP connection
  496.      */
  497.     protected XMPPConnection getConnection() {
  498.         return this.connection;
  499.     }

  501.     /**
  502.      * Returns the {@link InBandBytestreamListener} that should be informed if a In-Band Bytestream
  503.      * request from the given initiator JID is received.
  504.      * 
  505.      * @param initiator the initiator's JID
  506.      * @return the listener
  507.      */
  508.     protected BytestreamListener getUserListener(Jid initiator) {
  509.         return this.userListeners.get(initiator);
  510.     }

  512.     /**
  513.      * Returns a list of {@link InBandBytestreamListener} that are informed if there are no
  514.      * listeners for a specific initiator.
  515.      * 
  516.      * @return list of listeners
  517.      */
  518.     protected List<BytestreamListener> getAllRequestListeners() {
  519.         return this.allRequestListeners;
  520.     }

  522.     /**
  523.      * Returns the sessions map.
  524.      * 
  525.      * @return the sessions map
  526.      */
  527.     protected Map<String, InBandBytestreamSession> getSessions() {
  528.         return sessions;
  529.     }

  531.     /**
  532.      * Returns the list of session IDs that should be ignored by the InitialtionListener
  533.      * 
  534.      * @return list of session IDs
  535.      */
  536.     protected List<String> getIgnoredBytestreamRequests() {
  537.         return ignoredBytestreamRequests;
  538.     }

  540.     /**
  541.      * Disables the InBandBytestreamManager by removing its packet listeners and resetting its
  542.      * internal status, which includes removing this instance from the managers map.
  543.      */
  544.     private void disableService() {

  546.         // remove manager from static managers map
  547.         managers.remove(connection);

  549.         // remove all listeners registered by this manager
  550.         connection.unregisterIQRequestHandler(initiationListener);
  551.         connection.unregisterIQRequestHandler(dataListener);
  552.         connection.unregisterIQRequestHandler(closeListener);

  554.         // shutdown threads
  555.         this.initiationListener.shutdown();

  557.         // reset internal status
  558.         this.userListeners.clear();
  559.         this.allRequestListeners.clear();
  560.         this.sessions.clear();
  561.         this.ignoredBytestreamRequests.clear();

  563.     }

  565. }
Created with JaCoCo 0.7.4.201502262128