Bytestream.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.packet;

  19. import java.util.ArrayList;
  20. import java.util.Collections;
  21. import java.util.List;

  23. import org.jivesoftware.smack.packet.IQ;
  24. import org.jivesoftware.smack.packet.NamedElement;
  25. import org.jivesoftware.smack.util.XmlStringBuilder;
  26. import org.jxmpp.jid.Jid;

  28. /**
  29.  * A packet representing part of a SOCKS5 Bytestream negotiation.
  30.  * 
  31.  * @author Alexander Wenckus
  32.  */
  33. public class Bytestream extends IQ {

  35.     public static final String ELEMENT = QUERY_ELEMENT;

  37.     /**
  38.      * The XMPP namespace of the SOCKS5 Bytestream
  39.      */
  40.     public static final String NAMESPACE = "http://jabber.org/protocol/bytestreams";

  42.     private String sessionID;

  44.     private Mode mode = Mode.tcp;

  46.     private final List<StreamHost> streamHosts = new ArrayList<StreamHost>();

  48.     private StreamHostUsed usedHost;

  50.     private Activate toActivate;

  52.     /**
  53.      * The default constructor
  54.      */
  55.     public Bytestream() {
  56.         super(ELEMENT, NAMESPACE);
  57.     }

  59.     /**
  60.      * A constructor where the session ID can be specified.
  61.      * 
  62.      * @param SID The session ID related to the negotiation.
  63.      * @see #setSessionID(String)
  64.      */
  65.     public Bytestream(final String SID) {
  66.         this();
  67.         setSessionID(SID);
  68.     }

  70.     /**
  71.      * Set the session ID related to the bytestream. The session ID is a unique identifier used to
  72.      * differentiate between stream negotiations.
  73.      * 
  74.      * @param sessionID the unique session ID that identifies the transfer.
  75.      */
  76.     public void setSessionID(final String sessionID) {
  77.         this.sessionID = sessionID;
  78.     }

  80.     /**
  81.      * Returns the session ID related to the bytestream negotiation.
  82.      * 
  83.      * @return Returns the session ID related to the bytestream negotiation.
  84.      * @see #setSessionID(String)
  85.      */
  86.     public String getSessionID() {
  87.         return sessionID;
  88.     }

  90.     /**
  91.      * Set the transport mode. This should be put in the initiation of the interaction.
  92.      * 
  93.      * @param mode the transport mode, either UDP or TCP
  94.      * @see Mode
  95.      */
  96.     public void setMode(final Mode mode) {
  97.         this.mode = mode;
  98.     }

  100.     /**
  101.      * Returns the transport mode.
  102.      * 
  103.      * @return Returns the transport mode.
  104.      * @see #setMode(Mode)
  105.      */
  106.     public Mode getMode() {
  107.         return mode;
  108.     }

  110.     /**
  111.      * Adds a potential stream host that the remote user can connect to to receive the file.
  112.      * 
  113.      * @param JID The JID of the stream host.
  114.      * @param address The internet address of the stream host.
  115.      * @return The added stream host.
  116.      */
  117.     public StreamHost addStreamHost(final Jid JID, final String address) {
  118.         return addStreamHost(JID, address, 0);
  119.     }

  121.     /**
  122.      * Adds a potential stream host that the remote user can connect to to receive the file.
  123.      * 
  124.      * @param JID The JID of the stream host.
  125.      * @param address The internet address of the stream host.
  126.      * @param port The port on which the remote host is seeking connections.
  127.      * @return The added stream host.
  128.      */
  129.     public StreamHost addStreamHost(final Jid JID, final String address, final int port) {
  130.         StreamHost host = new StreamHost(JID, address, port);
  131.         addStreamHost(host);

  133.         return host;
  134.     }

  136.     /**
  137.      * Adds a potential stream host that the remote user can transfer the file through.
  138.      * 
  139.      * @param host The potential stream host.
  140.      */
  141.     public void addStreamHost(final StreamHost host) {
  142.         streamHosts.add(host);
  143.     }

  145.     /**
  146.      * Returns the list of stream hosts contained in the packet.
  147.      * 
  148.      * @return Returns the list of stream hosts contained in the packet.
  149.      */
  150.     public List<StreamHost> getStreamHosts() {
  151.         return Collections.unmodifiableList(streamHosts);
  152.     }

  154.     /**
  155.      * Returns the stream host related to the given JID, or null if there is none.
  156.      * 
  157.      * @param JID The JID of the desired stream host.
  158.      * @return Returns the stream host related to the given JID, or null if there is none.
  159.      */
  160.     public StreamHost getStreamHost(final Jid JID) {
  161.         if (JID == null) {
  162.             return null;
  163.         }
  164.         for (StreamHost host : streamHosts) {
  165.             if (host.getJID().equals(JID)) {
  166.                 return host;
  167.             }
  168.         }

  170.         return null;
  171.     }

  173.     /**
  174.      * Returns the count of stream hosts contained in this packet.
  175.      * 
  176.      * @return Returns the count of stream hosts contained in this packet.
  177.      */
  178.     public int countStreamHosts() {
  179.         return streamHosts.size();
  180.     }

  182.     /**
  183.      * Upon connecting to the stream host the target of the stream replies to the initiator with the
  184.      * JID of the SOCKS5 host that they used.
  185.      * 
  186.      * @param JID The JID of the used host.
  187.      */
  188.     public void setUsedHost(final Jid JID) {
  189.         this.usedHost = new StreamHostUsed(JID);
  190.     }

  192.     /**
  193.      * Returns the SOCKS5 host connected to by the remote user.
  194.      * 
  195.      * @return Returns the SOCKS5 host connected to by the remote user.
  196.      */
  197.     public StreamHostUsed getUsedHost() {
  198.         return usedHost;
  199.     }

  201.     /**
  202.      * Returns the activate element of the packet sent to the proxy host to verify the identity of
  203.      * the initiator and match them to the appropriate stream.
  204.      * 
  205.      * @return Returns the activate element of the packet sent to the proxy host to verify the
  206.      *         identity of the initiator and match them to the appropriate stream.
  207.      */
  208.     public Activate getToActivate() {
  209.         return toActivate;
  210.     }

  212.     /**
  213.      * Upon the response from the target of the used host the activate packet is sent to the SOCKS5
  214.      * proxy. The proxy will activate the stream or return an error after verifying the identity of
  215.      * the initiator, using the activate packet.
  216.      * 
  217.      * @param targetID The JID of the target of the file transfer.
  218.      */
  219.     public void setToActivate(final Jid targetID) {
  220.         this.toActivate = new Activate(targetID);
  221.     }

  223.     @Override
  224.     protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder xml) {
  225.         switch(getType()) {
  226.         case set:
  227.             xml.optAttribute("sid", getSessionID());
  228.             xml.optAttribute("mode", getMode());
  229.             xml.rightAngleBracket();
  230.             if (getToActivate() == null) {
  231.                 for (StreamHost streamHost : getStreamHosts()) {
  232.                     xml.append(streamHost.toXML());
  233.                 }
  234.             }
  235.             else {
  236.                 xml.append(getToActivate().toXML());
  237.             }
  238.             break;
  239.         case result:
  240.             xml.rightAngleBracket();
  241.             xml.optAppend(getUsedHost());
  242.             // TODO Bytestream can include either used host *or* streamHosts. Never both. This should be ensured by the
  243.             // constructions mechanisms of Bytestream
  244.             // A result from the server can also contain stream hosts
  245.             for (StreamHost host : streamHosts) {
  246.                 xml.append(host.toXML());
  247.             }
  248.             break;
  249.         case get:
  250.             xml.setEmptyElement();
  251.             break;
  252.         default:
  253.             throw new IllegalStateException();
  254.         }

  256.         return xml;
  257.     }

  259.     /**
  260.      * Packet extension that represents a potential SOCKS5 proxy for the file transfer. Stream hosts
  261.      * are forwarded to the target of the file transfer who then chooses and connects to one.
  262.      * 
  263.      * @author Alexander Wenckus
  264.      */
  265.     public static class StreamHost implements NamedElement {

  267.         public static String ELEMENTNAME = "streamhost";

  269.         private final Jid JID;

  271.         private final String addy;

  273.         private final int port;

  275.         public StreamHost(Jid jid, String address) {
  276.             this(jid, address, 0);
  277.         }

  279.         /**
  280.          * Default constructor.
  281.          * 
  282.          * @param JID The JID of the stream host.
  283.          * @param address The internet address of the stream host.
  284.          */
  285.         public StreamHost(final Jid JID, final String address, int port) {
  286.             this.JID = JID;
  287.             this.addy = address;
  288.             this.port = port;
  289.         }

  291.         /**
  292.          * Returns the JID of the stream host.
  293.          * 
  294.          * @return Returns the JID of the stream host.
  295.          */
  296.         public Jid getJID() {
  297.             return JID;
  298.         }

  300.         /**
  301.          * Returns the internet address of the stream host.
  302.          * 
  303.          * @return Returns the internet address of the stream host.
  304.          */
  305.         public String getAddress() {
  306.             return addy;
  307.         }

  309.         /**
  310.          * Returns the port on which the potential stream host would accept the connection.
  311.          * 
  312.          * @return Returns the port on which the potential stream host would accept the connection.
  313.          */
  314.         public int getPort() {
  315.             return port;
  316.         }

  318.         public String getElementName() {
  319.             return ELEMENTNAME;
  320.         }

  322.         @Override
  323.         public XmlStringBuilder toXML() {
  324.             XmlStringBuilder xml = new XmlStringBuilder(this);
  325.             xml.attribute("jid", getJID());
  326.             xml.attribute("host", getAddress());
  327.             if (getPort() != 0) {
  328.                 xml.attribute("port", Integer.toString(getPort()));
  329.             } else {
  330.                 xml.attribute("zeroconf", "_jabber.bytestreams");
  331.             }
  332.             xml.closeEmptyElement();
  333.             return xml;
  334.         }
  335.     }

  337.     /**
  338.      * After selected a SOCKS5 stream host and successfully connecting, the target of the file
  339.      * transfer returns a byte stream packet with the stream host used extension.
  340.      * 
  341.      * @author Alexander Wenckus
  342.      */
  343.     public static class StreamHostUsed implements NamedElement {

  345.         public static String ELEMENTNAME = "streamhost-used";

  347.         private final Jid JID;

  349.         /**
  350.          * Default constructor.
  351.          * 
  352.          * @param JID The JID of the selected stream host.
  353.          */
  354.         public StreamHostUsed(final Jid JID) {
  355.             this.JID = JID;
  356.         }

  358.         /**
  359.          * Returns the JID of the selected stream host.
  360.          * 
  361.          * @return Returns the JID of the selected stream host.
  362.          */
  363.         public Jid getJID() {
  364.             return JID;
  365.         }

  367.         public String getElementName() {
  368.             return ELEMENTNAME;
  369.         }

  371.         @Override
  372.         public XmlStringBuilder toXML() {
  373.             XmlStringBuilder xml = new XmlStringBuilder(this);
  374.             xml.attribute("jid", getJID());
  375.             xml.closeEmptyElement();
  376.             return xml;
  377.         }
  378.     }

  380.     /**
  381.      * The packet sent by the stream initiator to the stream proxy to activate the connection.
  382.      * 
  383.      * @author Alexander Wenckus
  384.      */
  385.     public static class Activate implements NamedElement {

  387.         public static String ELEMENTNAME = "activate";

  389.         private final Jid target;

  391.         /**
  392.          * Default constructor specifying the target of the stream.
  393.          * 
  394.          * @param target The target of the stream.
  395.          */
  396.         public Activate(final Jid target) {
  397.             this.target = target;
  398.         }

  400.         /**
  401.          * Returns the target of the activation.
  402.          * 
  403.          * @return Returns the target of the activation.
  404.          */
  405.         public Jid getTarget() {
  406.             return target;
  407.         }

  409.         public String getElementName() {
  410.             return ELEMENTNAME;
  411.         }

  413.         @Override
  414.         public XmlStringBuilder toXML() {
  415.             XmlStringBuilder xml = new XmlStringBuilder(this);
  416.             xml.rightAngleBracket();
  417.             xml.escape(getTarget());
  418.             xml.closeElement(this);
  419.             return xml;
  420.         }
  421.     }

  423.     /**
  424.      * The stream can be either a TCP stream or a UDP stream.
  425.      * 
  426.      * @author Alexander Wenckus
  427.      */
  428.     public enum Mode {

  430.         /**
  431.          * A TCP based stream.
  432.          */
  433.         tcp,

  435.         /**
  436.          * A UDP based stream.
  437.          */
  438.         udp;

  440.         public static Mode fromName(String name) {
  441.             Mode mode;
  442.             try {
  443.                 mode = Mode.valueOf(name);
  444.             }
  445.             catch (Exception ex) {
  446.                 mode = tcp;
  447.             }

  449.             return mode;
  450.         }
  451.     }
  452. }
Created with JaCoCo 0.7.4.201502262128