FileTransferNegotiator.java

  1. /**
  2.  *
  3.  * Copyright 2003-2006 Jive Software.
  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.filetransfer;

  19. import java.net.URLConnection;
  20. import java.util.ArrayList;
  21. import java.util.Arrays;
  22. import java.util.Collection;
  23. import java.util.Collections;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Random;
  27. import java.util.WeakHashMap;

  29. import org.jivesoftware.smack.Manager;
  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.XMPPException.XMPPErrorException;
  34. import org.jivesoftware.smack.packet.IQ;
  35. import org.jivesoftware.smack.packet.Stanza;
  36. import org.jivesoftware.smack.packet.XMPPError;
  37. import org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension;
  38. import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream;
  39. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  40. import org.jivesoftware.smackx.filetransfer.FileTransferException.NoAcceptableTransferMechanisms;
  41. import org.jivesoftware.smackx.filetransfer.FileTransferException.NoStreamMethodsOfferedException;
  42. import org.jivesoftware.smackx.si.packet.StreamInitiation;
  43. import org.jivesoftware.smackx.xdata.FormField;
  44. import org.jivesoftware.smackx.xdata.packet.DataForm;
  45. import org.jxmpp.jid.Jid;

  47. /**
  48.  * Manages the negotiation of file transfers according to XEP-0096. If a file is
  49.  * being sent the remote user chooses the type of stream under which the file
  50.  * will be sent.
  51.  *
  52.  * @author Alexander Wenckus
  53.  * @see <a href="http://xmpp.org/extensions/xep-0096.html">XEP-0096: SI File Transfer</a>
  54.  */
  55. public class FileTransferNegotiator extends Manager {

  57.     public static final String SI_NAMESPACE = "http://jabber.org/protocol/si";
  58.     public static final String SI_PROFILE_FILE_TRANSFER_NAMESPACE = "http://jabber.org/protocol/si/profile/file-transfer";
  59.     private static final String[] NAMESPACE = { SI_NAMESPACE, SI_PROFILE_FILE_TRANSFER_NAMESPACE };

  61.     private static final Map<XMPPConnection, FileTransferNegotiator> INSTANCES = new WeakHashMap<XMPPConnection, FileTransferNegotiator>();

  63.     private static final String STREAM_INIT_PREFIX = "jsi_";

  65.     protected static final String STREAM_DATA_FIELD_NAME = "stream-method";

  67.     private static final Random randomGenerator = new Random();

  69.     /**
  70.      * A static variable to use only offer IBB for file transfer. It is generally recommend to only
  71.      * set this variable to true for testing purposes as IBB is the backup file transfer method
  72.      * and shouldn't be used as the only transfer method in production systems.
  73.      */
  74.     public static boolean IBB_ONLY = (System.getProperty("ibb") != null);//true;

  76.     /**
  77.      * Returns the file transfer negotiator related to a particular connection.
  78.      * When this class is requested on a particular connection the file transfer
  79.      * service is automatically enabled.
  80.      *
  81.      * @param connection The connection for which the transfer manager is desired
  82.      * @return The FileTransferNegotiator
  83.      */
  84.     public static synchronized FileTransferNegotiator getInstanceFor(
  85.             final XMPPConnection connection) {
  86.         FileTransferNegotiator fileTransferNegotiator = INSTANCES.get(connection);
  87.         if (fileTransferNegotiator == null) {
  88.             fileTransferNegotiator = new FileTransferNegotiator(connection);
  89.             INSTANCES.put(connection, fileTransferNegotiator);
  90.         }
  91.         return fileTransferNegotiator;
  92.     }

  94.     /**
  95.      * Enable the Jabber services related to file transfer on the particular
  96.      * connection.
  97.      *
  98.      * @param connection The connection on which to enable or disable the services.
  99.      * @param isEnabled  True to enable, false to disable.
  100.      */
  101.     private static void setServiceEnabled(final XMPPConnection connection,
  102.             final boolean isEnabled) {
  103.         ServiceDiscoveryManager manager = ServiceDiscoveryManager
  104.                 .getInstanceFor(connection);

  106.         List<String> namespaces = new ArrayList<String>();
  107.         namespaces.addAll(Arrays.asList(NAMESPACE));
  108.         namespaces.add(DataPacketExtension.NAMESPACE);
  109.         if (!IBB_ONLY) {
  110.             namespaces.add(Bytestream.NAMESPACE);
  111.         }

  113.         for (String namespace : namespaces) {
  114.             if (isEnabled) {
  115.                 manager.addFeature(namespace);
  116.             } else {
  117.                 manager.removeFeature(namespace);
  118.             }
  119.         }
  120.     }

  122.     /**
  123.      * Checks to see if all file transfer related services are enabled on the
  124.      * connection.
  125.      *
  126.      * @param connection The connection to check
  127.      * @return True if all related services are enabled, false if they are not.
  128.      */
  129.     public static boolean isServiceEnabled(final XMPPConnection connection) {
  130.         ServiceDiscoveryManager manager = ServiceDiscoveryManager
  131.                 .getInstanceFor(connection);

  133.         List<String> namespaces = new ArrayList<String>();
  134.         namespaces.addAll(Arrays.asList(NAMESPACE));
  135.         namespaces.add(DataPacketExtension.NAMESPACE);
  136.         if (!IBB_ONLY) {
  137.             namespaces.add(Bytestream.NAMESPACE);
  138.         }

  140.         for (String namespace : namespaces) {
  141.             if (!manager.includesFeature(namespace)) {
  142.                 return false;
  143.             }
  144.         }
  145.         return true;
  146.     }

  148.     /**
  149.      * Returns a collection of the supported transfer protocols.
  150.      *
  151.      * @return Returns a collection of the supported transfer protocols.
  152.      */
  153.     public static Collection<String> getSupportedProtocols() {
  154.         List<String> protocols = new ArrayList<String>();
  155.         protocols.add(DataPacketExtension.NAMESPACE);
  156.         if (!IBB_ONLY) {
  157.             protocols.add(Bytestream.NAMESPACE);
  158.         }
  159.         return Collections.unmodifiableList(protocols);
  160.     }

  162.     // non-static

  164.     private final StreamNegotiator byteStreamTransferManager;

  166.     private final StreamNegotiator inbandTransferManager;

  168.     private FileTransferNegotiator(final XMPPConnection connection) {
  169.         super(connection);
  170.         byteStreamTransferManager = new Socks5TransferNegotiator(connection);
  171.         inbandTransferManager = new IBBTransferNegotiator(connection);

  173.         setServiceEnabled(connection, true);
  174.     }

  176.     /**
  177.      * Selects an appropriate stream negotiator after examining the incoming file transfer request.
  178.      *
  179.      * @param request The related file transfer request.
  180.      * @return The file transfer object that handles the transfer
  181.      * @throws NoStreamMethodsOfferedException If there are either no stream methods contained in the packet, or
  182.      *                       there is not an appropriate stream method.
  183.      * @throws NotConnectedException 
  184.      * @throws NoAcceptableTransferMechanisms 
  185.      * @throws InterruptedException 
  186.      */
  187.     public StreamNegotiator selectStreamNegotiator(
  188.             FileTransferRequest request) throws NotConnectedException, NoStreamMethodsOfferedException, NoAcceptableTransferMechanisms, InterruptedException {
  189.         StreamInitiation si = request.getStreamInitiation();
  190.         FormField streamMethodField = getStreamMethodField(si
  191.                 .getFeatureNegotiationForm());

  193.         if (streamMethodField == null) {
  194.             String errorMessage = "No stream methods contained in stanza.";
  195.             XMPPError error = XMPPError.from(XMPPError.Condition.bad_request, errorMessage);
  196.             IQ iqPacket = IQ.createErrorResponse(si, error);
  197.             connection().sendStanza(iqPacket);
  198.             throw new FileTransferException.NoStreamMethodsOfferedException();
  199.         }

  201.         // select the appropriate protocol
  202.         StreamNegotiator selectedStreamNegotiator;
  203.         try {
  204.             selectedStreamNegotiator = getNegotiator(streamMethodField);
  205.         }
  206.         catch (NoAcceptableTransferMechanisms e) {
  207.             IQ iqPacket = IQ.createErrorResponse(si, XMPPError.from(XMPPError.Condition.bad_request, "No acceptable transfer mechanism"));
  208.             connection().sendStanza(iqPacket);
  209.             throw e;
  210.         }

  212.         // return the appropriate negotiator

  214.         return selectedStreamNegotiator;
  215.     }

  217.     private FormField getStreamMethodField(DataForm form) {
  218.         for (FormField field : form.getFields()) {
  219.             if (field.getVariable().equals(STREAM_DATA_FIELD_NAME)) {
  220.                 return field;
  221.             }
  222.         }
  223.         return null;
  224.     }

  226.     private StreamNegotiator getNegotiator(final FormField field)
  227.             throws NoAcceptableTransferMechanisms {
  228.         String variable;
  229.         boolean isByteStream = false;
  230.         boolean isIBB = false;
  231.         for (FormField.Option option : field.getOptions()) {
  232.             variable = option.getValue();
  233.             if (variable.equals(Bytestream.NAMESPACE) && !IBB_ONLY) {
  234.                 isByteStream = true;
  235.             }
  236.             else if (variable.equals(DataPacketExtension.NAMESPACE)) {
  237.                 isIBB = true;
  238.             }
  239.         }

  241.         if (!isByteStream && !isIBB) {
  242.             throw new FileTransferException.NoAcceptableTransferMechanisms();
  243.         }

  245.         if (isByteStream && isIBB) { 
  246.             return new FaultTolerantNegotiator(connection(),
  247.                     byteStreamTransferManager,
  248.                     inbandTransferManager);
  249.         }
  250.         else if (isByteStream) {
  251.             return byteStreamTransferManager;
  252.         }
  253.         else {
  254.             return inbandTransferManager;
  255.         }
  256.     }

  258.     /**
  259.      * Returns a new, unique, stream ID to identify a file transfer.
  260.      *
  261.      * @return Returns a new, unique, stream ID to identify a file transfer.
  262.      */
  263.     public String getNextStreamID() {
  264.         StringBuilder buffer = new StringBuilder();
  265.         buffer.append(STREAM_INIT_PREFIX);
  266.         buffer.append(Math.abs(randomGenerator.nextLong()));

  268.         return buffer.toString();
  269.     }

  271.     /**
  272.      * Send a request to another user to send them a file. The other user has
  273.      * the option of, accepting, rejecting, or not responding to a received file
  274.      * transfer request.
  275.      * <p/>
  276.      * If they accept, the packet will contain the other user's chosen stream
  277.      * type to send the file across. The two choices this implementation
  278.      * provides to the other user for file transfer are <a
  279.      * href="http://www.xmpp.org/extensions/jep-0065.html">SOCKS5 Bytestreams</a>,
  280.      * which is the preferred method of transfer, and <a
  281.      * href="http://www.xmpp.org/extensions/jep-0047.html">In-Band Bytestreams</a>,
  282.      * which is the fallback mechanism.
  283.      * <p/>
  284.      * The other user may choose to decline the file request if they do not
  285.      * desire the file, their client does not support XEP-0096, or if there are
  286.      * no acceptable means to transfer the file.
  287.      * <p/>
  288.      * Finally, if the other user does not respond this method will return null
  289.      * after the specified timeout.
  290.      *
  291.      * @param userID          The userID of the user to whom the file will be sent.
  292.      * @param streamID        The unique identifier for this file transfer.
  293.      * @param fileName        The name of this file. Preferably it should include an
  294.      *                        extension as it is used to determine what type of file it is.
  295.      * @param size            The size, in bytes, of the file.
  296.      * @param desc            A description of the file.
  297.      * @param responseTimeout The amount of time, in milliseconds, to wait for the remote
  298.      *                        user to respond. If they do not respond in time, this
  299.      * @return Returns the stream negotiator selected by the peer.
  300.      * @throws XMPPErrorException Thrown if there is an error negotiating the file transfer.
  301.      * @throws NotConnectedException 
  302.      * @throws NoResponseException 
  303.      * @throws NoAcceptableTransferMechanisms 
  304.      * @throws InterruptedException 
  305.      */
  306.     public StreamNegotiator negotiateOutgoingTransfer(final Jid userID,
  307.             final String streamID, final String fileName, final long size,
  308.             final String desc, int responseTimeout) throws XMPPErrorException, NotConnectedException, NoResponseException, NoAcceptableTransferMechanisms, InterruptedException {
  309.         StreamInitiation si = new StreamInitiation();
  310.         si.setSessionID(streamID);
  311.         si.setMimeType(URLConnection.guessContentTypeFromName(fileName));

  313.         StreamInitiation.File siFile = new StreamInitiation.File(fileName, size);
  314.         siFile.setDesc(desc);
  315.         si.setFile(siFile);

  317.         si.setFeatureNegotiationForm(createDefaultInitiationForm());

  319.         si.setFrom(connection().getUser());
  320.         si.setTo(userID);
  321.         si.setType(IQ.Type.set);

  323.         Stanza siResponse = connection().createPacketCollectorAndSend(si).nextResultOrThrow(
  324.                         responseTimeout);

  326.         if (siResponse instanceof IQ) {
  327.             IQ iqResponse = (IQ) siResponse;
  328.             if (iqResponse.getType().equals(IQ.Type.result)) {
  329.                 StreamInitiation response = (StreamInitiation) siResponse;
  330.                 return getOutgoingNegotiator(getStreamMethodField(response
  331.                         .getFeatureNegotiationForm()));

  333.             }
  334.             else {
  335.                 throw new XMPPErrorException(iqResponse.getError());
  336.             }
  337.         }
  338.         else {
  339.             return null;
  340.         }
  341.     }

  343.     private StreamNegotiator getOutgoingNegotiator(final FormField field) throws NoAcceptableTransferMechanisms {
  344.         boolean isByteStream = false;
  345.         boolean isIBB = false;
  346.         for (String variable : field.getValues()) {
  347.             if (variable.equals(Bytestream.NAMESPACE) && !IBB_ONLY) {
  348.                 isByteStream = true;
  349.             }
  350.             else if (variable.equals(DataPacketExtension.NAMESPACE)) {
  351.                 isIBB = true;
  352.             }
  353.         }

  355.         if (!isByteStream && !isIBB) {
  356.             throw new FileTransferException.NoAcceptableTransferMechanisms();
  357.         }

  359.         if (isByteStream && isIBB) {
  360.             return new FaultTolerantNegotiator(connection(),
  361.                     byteStreamTransferManager, inbandTransferManager);
  362.         }
  363.         else if (isByteStream) {
  364.             return byteStreamTransferManager;
  365.         }
  366.         else {
  367.             return inbandTransferManager;
  368.         }
  369.     }

  371.     private DataForm createDefaultInitiationForm() {
  372.         DataForm form = new DataForm(DataForm.Type.form);
  373.         FormField field = new FormField(STREAM_DATA_FIELD_NAME);
  374.         field.setType(FormField.Type.list_single);
  375.         if (!IBB_ONLY) {
  376.             field.addOption(new FormField.Option(Bytestream.NAMESPACE));
  377.         }
  378.         field.addOption(new FormField.Option(DataPacketExtension.NAMESPACE));
  379.         form.addField(field);
  380.         return form;
  381.     }
  382. }
Created with JaCoCo 0.7.4.201502262128