54 files changed, 5566 insertions, 29 deletions
diff --git a/src/com/isode/stroke/base/SafeByteArray.java b/src/com/isode/stroke/base/SafeByteArray.java
index e193299..437346f 100644
--- a/src/com/isode/stroke/base/SafeByteArray.java
+++ b/src/com/isode/stroke/base/SafeByteArray.java
@@ -61,6 +61,11 @@ public class SafeByteArray extends ByteArray {
 		return this;
 	}
 
+	public SafeByteArray append(SafeByteArray b) {
+		append(b.getData());
+		return this;
+	}
+
 	/** 
 	 * Updates the SafeByteArray by adding all the bytes
 	 * in a byte[] to the end of the array (mutable add).  
@@ -102,4 +107,4 @@ public class SafeByteArray extends ByteArray {
 		super.append(s);
 		return this;
 	}
-}
-\ No newline at end of file
+}
diff --git a/src/com/isode/stroke/client/Client.java b/src/com/isode/stroke/client/Client.java
index 464e062..07ac885 100644
--- a/src/com/isode/stroke/client/Client.java
+++ b/src/com/isode/stroke/client/Client.java
@@ -30,6 +30,10 @@ import com.isode.stroke.signals.Signal1;
 import com.isode.stroke.vcards.VCardManager;
 import com.isode.stroke.base.SafeByteArray;
 import com.isode.stroke.tls.BlindCertificateTrustChecker;
+import com.isode.stroke.filetransfer.FileTransferManager;
+import com.isode.stroke.filetransfer.FileTransferManagerImpl;
+import com.isode.stroke.jingle.JingleSessionManager;
+import com.isode.stroke.filetransfer.DummyFileTransferManager;
 
 /**
  * Provides the core functionality for writing XMPP client software.
@@ -59,8 +63,8 @@ public class Client extends CoreClient {
     private final SubscriptionManager subscriptionManager;
     private final ClientDiscoManager discoManager;
     private final AvatarManager avatarManager;
-    //private final JingleSessionManager jingleSessionManager;
-    //private final FileTransferManager fileTransferManager;
+    private final JingleSessionManager jingleSessionManager;
+    private final FileTransferManager fileTransferManager;
     private final BlindCertificateTrustChecker blindCertificateTrustChecker;
     //private final WhiteboardSessionManager whiteboardSessionManager;
     private final ClientBlockListManager blockListManager;
@@ -117,8 +121,7 @@ public class Client extends CoreClient {
 
         blindCertificateTrustChecker = new BlindCertificateTrustChecker();
 
-        //TO PORT
-        //jingleSessionManager = new JingleSessionManager(getIQRouter());
+        jingleSessionManager = new JingleSessionManager(getIQRouter());
         blockListManager = new ClientBlockListManager(getIQRouter());
 
         /*whiteboardSessionManager = NULL;
@@ -135,16 +138,16 @@ public class Client extends CoreClient {
                     getIQRouter(),
                     getEntityCapsProvider(),
                     presenceOracle,
-                    getNetworkFactories()->getConnectionFactory(),
-                    getNetworkFactories()->getConnectionServerFactory(),
-                    getNetworkFactories()->getTimerFactory(),
-                    getNetworkFactories()->getDomainNameResolver(),
-                    getNetworkFactories()->getNetworkEnvironment(),
-                    getNetworkFactories()->getNATTraverser(),
-                    getNetworkFactories()->getCryptoProvider());
-        #else
-            fileTransferManager = new DummyFileTransferManager();
-        #endif*/
+                    getNetworkFactories().getConnectionFactory(),
+                    getNetworkFactories().getConnectionServerFactory(),
+                    getNetworkFactories().getTimerFactory(),
+                    getNetworkFactories().getDomainNameResolver(),
+                    getNetworkFactories().getNetworkEnvironment(),
+                    getNetworkFactories().getNATTraverser(),
+                    getNetworkFactories().getCryptoProvider());
+        #else*/
+        fileTransferManager = new DummyFileTransferManager();
+        //#endif
     }
 
     /**
@@ -266,10 +269,9 @@ public class Client extends CoreClient {
      *
      * WARNING: File transfer will only work if Swiften is built in 'experimental' mode.
      */
-    //TO PORT
-    /*public FileTransferManager getFileTransferManager() {
+    public FileTransferManager getFileTransferManager() {
         return fileTransferManager;
-    }*/
+    }
 
     /**
      * Configures the client to always trust a non-validating
diff --git a/src/com/isode/stroke/disco/FeatureOracle.java b/src/com/isode/stroke/disco/FeatureOracle.java
index e01b2ab..12a45b4 100644
--- a/src/com/isode/stroke/disco/FeatureOracle.java
+++ b/src/com/isode/stroke/disco/FeatureOracle.java
@@ -17,7 +17,7 @@ import com.isode.stroke.elements.Presence;
 import com.isode.stroke.jid.JID;
 import com.isode.stroke.disco.EntityCapsProvider;
 import com.isode.stroke.presence.PresenceOracle;
-//import com.isode.stroke.filetransfer.FileTransferManager;
+import com.isode.stroke.filetransfer.FileTransferManager;
 import java.util.List;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -32,10 +32,7 @@ public class FeatureOracle {
 		this.presenceOracle_ = presenceOracle;
 	}
 
-	/**
-	* To PORT : FileTransfer.
-	*/
-	/*public Tristate isFileTransferSupported(JID jid) {
+	public Tristate isFileTransferSupported(JID jid) {
 		DiscoInfo discoInfo = getDiscoResultForJID(jid);
 		if (discoInfo != null) {
 			return FileTransferManager.isSupportedBy(discoInfo) ? Tristate.Yes : Tristate.No;
@@ -43,7 +40,7 @@ public class FeatureOracle {
 		else {
 			return Tristate.Maybe;
 		}
-	}*/
+	}
 
 	public Tristate isMessageReceiptsSupported(JID jid) {
 		return isFeatureSupported(jid, DiscoInfo.MessageDeliveryReceiptsFeature);
diff --git a/src/com/isode/stroke/elements/JingleS5BTransportPayload.java b/src/com/isode/stroke/elements/JingleS5BTransportPayload.java
index e9ee67f..546a41a 100644
--- a/src/com/isode/stroke/elements/JingleS5BTransportPayload.java
+++ b/src/com/isode/stroke/elements/JingleS5BTransportPayload.java
@@ -17,6 +17,7 @@ import com.isode.stroke.network.HostAddressPort;
 import com.isode.stroke.jid.JID;
 import com.isode.stroke.base.NotNull;
 import java.util.Vector;
+import java.util.Comparator;
 
 public class JingleS5BTransportPayload extends JingleTransportPayload {
 
@@ -46,9 +47,20 @@ public class JingleS5BTransportPayload extends JingleTransportPayload {
 		}
 	}
 
-	public class CompareCandidate {
-		public boolean compareTo(JingleS5BTransportPayload.Candidate c1, JingleS5BTransportPayload.Candidate c2) {
-			return (c1.priority < c2.priority);
+	public static class CompareCandidate implements Comparator<JingleS5BTransportPayload.Candidate> {
+		public int compare(JingleS5BTransportPayload.Candidate c1, JingleS5BTransportPayload.Candidate c2) {
+			if (c1.priority == c2.priority) { return 0; }
+			else if (c1.priority < c2.priority) { return -1; }
+			else  { return 1; }
+		}
+
+		public boolean equals(Object c) {
+			if(!(c instanceof JingleS5BTransportPayload.Candidate)) {
+				return false;
+			}
+			else {
+				return this.equals(c);
+			}
 		}
 	}
 
diff --git a/src/com/isode/stroke/elements/S5BProxyRequest.java b/src/com/isode/stroke/elements/S5BProxyRequest.java
new file mode 100644
index 0000000..9d0c651
--- /dev/null
+++ b/src/com/isode/stroke/elements/S5BProxyRequest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.elements;
+
+import com.isode.stroke.elements.Payload;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.base.NotNull;
+import com.isode.stroke.elements.Bytestreams;
+
+public class S5BProxyRequest extends Payload {
+
+	private StreamHost streamHost;
+	private String sid = "";
+	private JID activate;
+
+	public static class StreamHost {
+		public String host = "";
+		public int port;
+		public JID jid = new JID();
+	};
+
+	/**
+	* Default Constructor.
+	*/
+	public S5BProxyRequest() {
+
+	}
+
+	/**
+	* @return streamHost.
+	*/
+	public StreamHost getStreamHost() {
+		return streamHost;
+	}
+
+	/**
+	* @param streamHost.
+	*/
+	public void setStreamHost(StreamHost streamHost) {
+		this.streamHost = streamHost;
+	}
+
+	/**
+	* @return sid, Not Null.
+	*/
+	public String getSID() {
+		return sid;
+	}
+
+	/**
+	* @param sid, Not Null.
+	*/
+	public void setSID(String sid) {
+		NotNull.exceptIfNull(sid, "sid");
+		this.sid = sid;
+	}
+
+	/**
+	* @return activate.
+	*/
+	public JID getActivate() {
+		return activate;
+	}
+
+	/**
+	* @param activate.
+	*/
+	public void setActivate(JID activate) {
+		this.activate = activate;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/ByteArrayReadBytestream.java b/src/com/isode/stroke/filetransfer/ByteArrayReadBytestream.java
new file mode 100644
index 0000000..4c3d47d
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/ByteArrayReadBytestream.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.base.ByteArray;
+
+public class ByteArrayReadBytestream extends ReadBytestream {
+
+	private ByteArray data;
+	private int position;
+	private boolean dataComplete;
+
+	public ByteArrayReadBytestream(final ByteArray data) {
+		this.data = data;
+		this.position = 0;
+		this.dataComplete = true;
+	}
+
+	public ByteArray read(int size) {
+		int readSize = size;
+		if (position + readSize > data.getSize()) {
+			readSize = data.getSize() - position;
+		}
+		String s = new String(data.getData());
+		s = s.substring(position, position+readSize);
+		ByteArray result = new ByteArray(s);
+
+		onRead.emit(result);
+		position += readSize;
+		return result;
+	}
+
+	public boolean isFinished() {
+		return position >= data.getSize() && dataComplete;
+	}
+
+	public void setDataComplete(boolean b) {
+		dataComplete = b;
+	}
+
+	public void addData(final ByteArray moreData) {
+		data.append(moreData);
+		onDataAvailable.emit();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/ByteArrayWriteBytestream.java b/src/com/isode/stroke/filetransfer/ByteArrayWriteBytestream.java
new file mode 100644
index 0000000..eb3a30f
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/ByteArrayWriteBytestream.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.base.ByteArray;
+
+public class ByteArrayWriteBytestream extends WriteBytestream {
+
+	private ByteArray data = new ByteArray();
+
+	public ByteArrayWriteBytestream() {
+	}
+
+	public void write(final ByteArray bytes) {
+		data.append(bytes);
+		onWrite.emit(bytes);
+	}
+
+	public ByteArray getData() {
+		return data;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/BytestreamException.java b/src/com/isode/stroke/filetransfer/BytestreamException.java
new file mode 100644
index 0000000..addac30
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/BytestreamException.java
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+public class BytestreamException extends Exception {
+
+	public BytestreamException(String s) {
+		super(s);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/BytestreamsRequest.java b/src/com/isode/stroke/filetransfer/BytestreamsRequest.java
new file mode 100644
index 0000000..a975b3d
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/BytestreamsRequest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.elements.Bytestreams;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.jid.JID;
+
+public class BytestreamsRequest extends GenericRequest<Bytestreams> {
+
+	public static BytestreamsRequest create(final JID jid, Bytestreams payload, IQRouter router) {
+		return new BytestreamsRequest(jid, payload, router);
+	}
+
+	public static BytestreamsRequest create(final JID from, final JID to, Bytestreams payload, IQRouter router) {
+		return new BytestreamsRequest(from, to, payload, router);
+	}
+
+	private BytestreamsRequest(final JID jid, Bytestreams payload, IQRouter router) {
+		super(IQ.Type.Set, jid, payload, router);
+	}
+
+	private BytestreamsRequest(final JID from, final JID to, Bytestreams payload, IQRouter router) {
+		super(IQ.Type.Set, from, to, payload, router);
+	}
+}
diff --git a/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporter.java b/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporter.java
new file mode 100644
index 0000000..f06407e
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporter.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.signals.Signal2;
+import com.isode.stroke.signals.Signal3;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+import java.util.logging.Logger;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.base.SafeByteArray;
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.elements.S5BProxyRequest;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.stringcodecs.Hexify;
+
+public class DefaultFileTransferTransporter extends FileTransferTransporter {
+
+	private JID initiator;
+	private JID responder;
+	private Role role;
+	private SOCKS5BytestreamRegistry s5bRegistry;
+	private SOCKS5BytestreamServerManager s5bServerManager;
+	private SOCKS5BytestreamProxiesManager s5bProxy;
+	private CryptoProvider crypto;
+	private IQRouter router;
+	private LocalJingleTransportCandidateGenerator localCandidateGenerator;
+	private RemoteJingleTransportCandidateSelector remoteCandidateSelector;
+	private String s5bSessionID;
+	private SOCKS5BytestreamClientSession remoteS5BClientSession;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public enum Role {
+		Initiator,
+		Responder
+	};
+
+	public DefaultFileTransferTransporter(
+		final JID initiator, 
+		final JID responder,
+		Role role,
+		SOCKS5BytestreamRegistry s5bRegistry, 
+		SOCKS5BytestreamServerManager s5bServerManager,
+		SOCKS5BytestreamProxiesManager s5bProxy, 
+		IDGenerator idGenerator, 
+		ConnectionFactory connectionFactory, 
+		TimerFactory timerFactory, 
+		CryptoProvider crypto,
+		IQRouter router,
+		final FileTransferOptions options) {
+		this.initiator = initiator;
+		this.responder = responder;
+		this.role = role;
+		this.s5bRegistry = s5bRegistry;
+		this.s5bProxy = s5bProxy;
+		this.crypto = crypto;
+		this.router = router;
+		localCandidateGenerator = new LocalJingleTransportCandidateGenerator(
+				s5bServerManager,
+				s5bProxy,
+				(Role.Initiator.equals(role) ? initiator : responder),
+				idGenerator,
+				options);
+		localCandidateGenerator.onLocalTransportCandidatesGenerated.connect(new Slot1<Vector<JingleS5BTransportPayload.Candidate>>() {
+			@Override
+			public void call(Vector<JingleS5BTransportPayload.Candidate> e) {
+				handleLocalCandidatesGenerated(e);
+			}
+		});
+
+		remoteCandidateSelector = new RemoteJingleTransportCandidateSelector(
+				connectionFactory,
+				timerFactory,
+				options);
+		remoteCandidateSelector.onCandidateSelectFinished.connect(new Slot2<JingleS5BTransportPayload.Candidate, SOCKS5BytestreamClientSession>() {
+			@Override
+			public void call(JingleS5BTransportPayload.Candidate c, SOCKS5BytestreamClientSession s) {
+				handleRemoteCandidateSelectFinished(c, s);
+			}
+		});
+	}
+
+	public void initialize() {
+		s5bSessionID = s5bRegistry.generateSessionID();
+	}
+
+	public void initialize(final String s5bSessionID) {
+		this.s5bSessionID = s5bSessionID;
+	}
+
+	public void startGeneratingLocalCandidates() {
+		localCandidateGenerator.start();
+	}
+
+	public void stopGeneratingLocalCandidates() {
+		localCandidateGenerator.stop();
+	}
+
+	public void addRemoteCandidates(
+					final Vector<JingleS5BTransportPayload.Candidate> candidates, final String dstAddr) {
+		remoteCandidateSelector.setSOCKS5DstAddr(dstAddr.isEmpty() ? getRemoteCandidateSOCKS5DstAddr() : dstAddr);
+		remoteCandidateSelector.addCandidates(candidates);
+	}
+
+	public void startTryingRemoteCandidates() {
+		remoteCandidateSelector.startSelectingCandidate();
+	}
+
+	public void stopTryingRemoteCandidates() {
+		remoteCandidateSelector.stopSelectingCandidate();
+	}
+
+	public void startActivatingProxy(final JID proxyServiceJID) {
+		// activate proxy
+		logger_.fine("Start activating proxy " + proxyServiceJID.toString() + " with sid = " + s5bSessionID + ".\n");
+		S5BProxyRequest proxyRequest = new S5BProxyRequest();
+		proxyRequest.setSID(s5bSessionID);
+		proxyRequest.setActivate(Role.Initiator.equals(role) ? responder : initiator);
+
+		GenericRequest<S5BProxyRequest> request = new GenericRequest<S5BProxyRequest>(IQ.Type.Set, proxyServiceJID, proxyRequest, router);
+		request.onResponse.connect(new Slot2<S5BProxyRequest, ErrorPayload>() {
+			@Override
+			public void call(S5BProxyRequest s, ErrorPayload e) {
+				handleActivateProxySessionResult(s5bSessionID, e);
+			}
+		});
+		request.send();
+	}
+
+	public void stopActivatingProxy() {
+		// TODO
+		assert(false);
+	}
+
+	public TransportSession createIBBSendSession(
+					final String sessionID, int blockSize, ReadBytestream stream) {
+		if (s5bServerManager.getServer() != null) {
+			closeLocalSession();
+		}
+		closeRemoteSession();
+		IBBSendSession ibbSession = new IBBSendSession(
+				sessionID, initiator, responder, stream, router);
+		ibbSession.setBlockSize(blockSize);
+		return new IBBSendTransportSession(ibbSession);
+	}
+
+	public TransportSession createIBBReceiveSession(
+					final String sessionID, int size, WriteBytestream stream) {
+		if (s5bServerManager.getServer() != null) {
+			closeLocalSession();
+		}
+		closeRemoteSession();
+		IBBReceiveSession ibbSession = new IBBReceiveSession(
+				sessionID, initiator, responder, size, stream, router);
+		return new IBBReceiveTransportSession(ibbSession);
+	}
+
+	public TransportSession createRemoteCandidateSession(
+					ReadBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		closeLocalSession();
+		return new S5BTransportSession<SOCKS5BytestreamClientSession>(
+			remoteS5BClientSession, stream);
+	}
+
+	public TransportSession createRemoteCandidateSession(
+					WriteBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		closeLocalSession();
+		return new S5BTransportSession<SOCKS5BytestreamClientSession>(
+			remoteS5BClientSession, stream);
+	}
+
+	public TransportSession createLocalCandidateSession(
+					ReadBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		closeRemoteSession();
+		TransportSession transportSession = null;
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(candidate.type)) {
+			SOCKS5BytestreamClientSession proxySession = s5bProxy.getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());
+			assert(proxySession != null);
+			transportSession = new S5BTransportSession<SOCKS5BytestreamClientSession>(proxySession, stream);
+		}
+
+		if (transportSession == null) {
+			SOCKS5BytestreamServerSession serverSession = getServerSession();
+			if (serverSession != null) {
+				transportSession = new S5BTransportSession<SOCKS5BytestreamServerSession>(serverSession, stream);
+			}
+		}
+
+		if (transportSession == null) {
+			transportSession = new FailingTransportSession();
+		}
+		return transportSession;
+	}
+
+	public TransportSession createLocalCandidateSession(
+					WriteBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		closeRemoteSession();
+		TransportSession transportSession = null;
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(candidate.type)) {
+			SOCKS5BytestreamClientSession proxySession = s5bProxy.getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());
+			assert(proxySession != null);
+			transportSession = new S5BTransportSession<SOCKS5BytestreamClientSession>(proxySession, stream);
+		}
+
+		if (transportSession == null) {
+			SOCKS5BytestreamServerSession serverSession = getServerSession();
+			if (serverSession != null) {
+				transportSession = new S5BTransportSession<SOCKS5BytestreamServerSession>(serverSession, stream);
+			}
+		}
+
+		if (transportSession == null) {
+			transportSession = new FailingTransportSession();
+		}
+		return transportSession;
+	}
+
+	private void handleLocalCandidatesGenerated(final Vector<JingleS5BTransportPayload.Candidate> candidates) {
+		s5bRegistry.setHasBytestream(getSOCKS5DstAddr(), true);
+		s5bProxy.connectToProxies(getSOCKS5DstAddr());
+		onLocalCandidatesGenerated.emit(s5bSessionID, candidates, getSOCKS5DstAddr());
+	}
+
+	private void handleRemoteCandidateSelectFinished(
+			final JingleS5BTransportPayload.Candidate candidate, 
+			SOCKS5BytestreamClientSession session) {
+		remoteS5BClientSession = session;
+		onRemoteCandidateSelectFinished.emit(s5bSessionID, candidate);
+	}
+
+	private void handleActivateProxySessionResult(final String sessionID, ErrorPayload error) {
+		onProxyActivated.emit(sessionID, error);
+	}
+
+	private void closeLocalSession() {
+		s5bRegistry.setHasBytestream(getSOCKS5DstAddr(), false);
+		if (s5bServerManager.getServer() != null) {
+			Vector<SOCKS5BytestreamServerSession> serverSessions = s5bServerManager.getServer().getSessions(getSOCKS5DstAddr());
+			for(SOCKS5BytestreamServerSession session : serverSessions) {
+				session.stop();
+			}
+		}
+	}
+	private void closeRemoteSession() {
+		if (remoteS5BClientSession != null) {
+			remoteS5BClientSession.stop();
+			remoteS5BClientSession = null;
+		}
+	}
+
+	private SOCKS5BytestreamServerSession getServerSession() {
+		s5bRegistry.setHasBytestream(getSOCKS5DstAddr(), false);
+		Vector<SOCKS5BytestreamServerSession> serverSessions = s5bServerManager.getServer().getSessions(getSOCKS5DstAddr());
+		while (serverSessions.size() > 1) {
+			SOCKS5BytestreamServerSession session = serverSessions.lastElement();
+			serverSessions.remove(serverSessions.lastElement());
+			session.stop();
+		}
+		return !serverSessions.isEmpty() ? serverSessions.get(0) : null;
+	}
+
+	private String getSOCKS5DstAddr() {
+		String result = "";
+		if (Role.Initiator.equals(role)) {
+			result = getInitiatorCandidateSOCKS5DstAddr();
+			logger_.fine("Initiator S5B DST.ADDR = " + s5bSessionID + " + " + initiator.toString() + " + " + responder.toString() + " : " + result + "\n");
+		}
+		else {
+			result = getResponderCandidateSOCKS5DstAddr();
+			logger_.fine("Responder S5B DST.ADDR = " + s5bSessionID + " + " + responder.toString() + " + " + initiator.toString() + " : " + result + "\n");
+		}
+		return result;
+	}
+
+	private String getInitiatorCandidateSOCKS5DstAddr() {
+		return Hexify.hexify(crypto.getSHA1Hash(new SafeByteArray(s5bSessionID + initiator.toString() + responder.toString())));
+	}
+
+	private String getResponderCandidateSOCKS5DstAddr() {
+		return Hexify.hexify(crypto.getSHA1Hash(new SafeByteArray(s5bSessionID + responder.toString() + initiator.toString())));
+	}
+
+	private String getRemoteCandidateSOCKS5DstAddr() {
+		if (Role.Initiator.equals(role)) {
+			return getResponderCandidateSOCKS5DstAddr();
+		}
+		else {
+			return getInitiatorCandidateSOCKS5DstAddr();
+		}
+	}
+
+	private String getLocalCandidateSOCKS5DstAddr() {
+		if (Role.Responder.equals(role)) {
+			return getResponderCandidateSOCKS5DstAddr();
+		}
+		else {
+			return getInitiatorCandidateSOCKS5DstAddr();
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporterFactory.java b/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporterFactory.java
new file mode 100644
index 0000000..3f15cc3
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/DefaultFileTransferTransporterFactory.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.signals.Signal2;
+import com.isode.stroke.signals.Signal3;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+import java.util.logging.Logger;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.base.SafeByteArray;
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.elements.S5BProxyRequest;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.stringcodecs.Hexify;
+
+public class DefaultFileTransferTransporterFactory implements FileTransferTransporterFactory {
+
+	private SOCKS5BytestreamRegistry s5bRegistry; 
+	private SOCKS5BytestreamServerManager s5bServerManager;
+	private SOCKS5BytestreamProxiesManager s5bProxiesManager; 
+	private IDGenerator idGenerator; 
+	private ConnectionFactory connectionFactory; 
+	private TimerFactory timerFactory; 
+	private CryptoProvider cryptoProvider;
+	private IQRouter iqRouter;
+
+	DefaultFileTransferTransporterFactory(
+		SOCKS5BytestreamRegistry s5bRegistry, 
+		SOCKS5BytestreamServerManager s5bServerManager,
+		SOCKS5BytestreamProxiesManager s5bProxy, 
+		IDGenerator idGenerator, 
+		ConnectionFactory connectionFactory, 
+		TimerFactory timerFactory, 
+		CryptoProvider cryptoProvider,
+		IQRouter iqRouter) {
+		this.s5bRegistry = s5bRegistry;
+		this.s5bProxiesManager = s5bProxy;
+		this.s5bServerManager = s5bServerManager;
+		this.idGenerator = idGenerator;
+		this.connectionFactory = connectionFactory;
+		this.timerFactory = timerFactory;
+		this.cryptoProvider = cryptoProvider;
+		this.iqRouter = iqRouter;
+	}
+
+	public FileTransferTransporter createInitiatorTransporter(
+			final JID initiator, final JID responder, final FileTransferOptions options) {
+		DefaultFileTransferTransporter transporter = new DefaultFileTransferTransporter(
+			initiator, 
+			responder,
+			DefaultFileTransferTransporter.Role.Initiator,
+			s5bRegistry,
+			s5bServerManager,
+			s5bProxiesManager,
+			idGenerator,
+			connectionFactory,
+			timerFactory,
+			cryptoProvider,
+			iqRouter,
+			options);
+		transporter.initialize();
+		return transporter;
+	}
+
+	public FileTransferTransporter createResponderTransporter(
+			final JID initiator, final JID responder, final String s5bSessionID, final FileTransferOptions options) {
+		DefaultFileTransferTransporter transporter = new DefaultFileTransferTransporter(
+			initiator, 
+			responder,
+			DefaultFileTransferTransporter.Role.Responder,
+			s5bRegistry,
+			s5bServerManager,
+			s5bProxiesManager,
+			idGenerator,
+			connectionFactory,
+			timerFactory,
+			cryptoProvider,
+			iqRouter,
+			options);
+		transporter.initialize(s5bSessionID);
+		return transporter;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/DummyFileTransferManager.java b/src/com/isode/stroke/filetransfer/DummyFileTransferManager.java
new file mode 100644
index 0000000..d45d9e6
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/DummyFileTransferManager.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.elements.DiscoInfo;
+import com.isode.stroke.elements.S5BProxyRequest;
+import java.util.Date;
+
+public class DummyFileTransferManager extends FileTransferManager {
+
+	public DummyFileTransferManager() {
+		super();
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to, 
+			final String filepath, 
+			final String description, 
+			ReadBytestream bytestream,
+			final FileTransferOptions op) {
+		return null;
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to,
+			final String filename, 
+			final String description, 
+			final long sizeInBytes, 
+			final Date lastModified, 
+			ReadBytestream bytestream,
+			final FileTransferOptions op) {
+		return null;
+	}
+
+	public void addS5BProxy(S5BProxyRequest p) {
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/DummyFileTransferTransporterFactory.java b/src/com/isode/stroke/filetransfer/DummyFileTransferTransporterFactory.java
new file mode 100644
index 0000000..10b630d
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/DummyFileTransferTransporterFactory.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.signals.Signal2;
+import com.isode.stroke.signals.Signal3;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+import java.util.logging.Logger;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.base.SafeByteArray;
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.elements.S5BProxyRequest;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.stringcodecs.Hexify;
+import com.isode.stroke.elements.S5BProxyRequest;
+
+class DummyFileTransferTransporter extends FileTransferTransporter {
+
+	public enum Role {
+		Initiator,
+		Responder
+	};
+
+	public DummyFileTransferTransporter(
+			final JID initiator,
+			final JID responder,
+			Role role,
+			SOCKS5BytestreamRegistry s5bRegistry,
+			SOCKS5BytestreamServerManager s5bServerManager,
+			SOCKS5BytestreamProxiesManager s5bProxy,
+			IDGenerator idGenerator,
+			ConnectionFactory connectionFactory,
+			TimerFactory timer,
+			CryptoProvider cryptoProvider,
+			IQRouter iqRouter,
+			final FileTransferOptions option) {
+		initiator_ = initiator;
+		responder_ = responder;
+		role_ = role;
+		s5bRegistry_ = s5bRegistry;
+		crypto_ = cryptoProvider;
+		iqRouter_ = iqRouter;
+	}
+
+	public void initialize() {
+		s5bSessionID_ = s5bRegistry_.generateSessionID();
+	}
+
+	public void startGeneratingLocalCandidates() {
+		Vector<JingleS5BTransportPayload.Candidate> candidates = new Vector<JingleS5BTransportPayload.Candidate>();
+		onLocalCandidatesGenerated.emit(s5bSessionID_, candidates, getSOCKS5DstAddr());
+	}
+
+	public void stopGeneratingLocalCandidates() {
+	}
+
+	public void addRemoteCandidates(final Vector<JingleS5BTransportPayload.Candidate> candidates, final String d) {
+	}
+
+	public void startTryingRemoteCandidates() {
+		onRemoteCandidateSelectFinished.emit(s5bSessionID_, null);
+	}
+
+	public void stopTryingRemoteCandidates() {
+	}
+
+	public void startActivatingProxy(final JID proxy) {
+	}
+
+	public void stopActivatingProxy() {
+	}
+
+	public TransportSession createIBBSendSession(final String sessionID, int blockSize, ReadBytestream stream) {
+		IBBSendSession ibbSession =new IBBSendSession(
+				sessionID, initiator_, responder_, stream, iqRouter_);
+		ibbSession.setBlockSize(blockSize);
+		return new IBBSendTransportSession(ibbSession);
+	}
+
+	public TransportSession createIBBReceiveSession(final String sessionID, int size, WriteBytestream stream) {
+		IBBReceiveSession ibbSession = new IBBReceiveSession(
+				sessionID, initiator_, responder_, size, stream, iqRouter_);
+		return new IBBReceiveTransportSession(ibbSession);
+	}
+
+	public TransportSession createRemoteCandidateSession(
+			ReadBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		return null;
+	}
+
+	public TransportSession createRemoteCandidateSession(
+			WriteBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		return null;
+	}
+
+	public TransportSession createLocalCandidateSession(
+			ReadBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		return null;
+	}
+
+	public TransportSession createLocalCandidateSession(
+			WriteBytestream stream, final JingleS5BTransportPayload.Candidate candidate) {
+		return null;
+	}
+
+	private String getSOCKS5DstAddr() {
+		String result = "";
+		if (Role.Initiator.equals(role_)) {
+			result = getInitiatorCandidateSOCKS5DstAddr();
+		}
+		else {
+			result = getResponderCandidateSOCKS5DstAddr();
+		}
+		return result;
+	}
+
+	private String getInitiatorCandidateSOCKS5DstAddr() {
+		return Hexify.hexify(crypto_.getSHA1Hash(new SafeByteArray(s5bSessionID_ + initiator_.toString() + responder_.toString())));
+	}
+
+	private String getResponderCandidateSOCKS5DstAddr() {
+		return Hexify.hexify(crypto_.getSHA1Hash(new SafeByteArray(s5bSessionID_ + responder_.toString() + initiator_.toString())));
+	}
+
+	private JID initiator_;
+	private JID responder_;
+	private Role role_;
+	private SOCKS5BytestreamRegistry s5bRegistry_;
+	private CryptoProvider crypto_;
+	private String s5bSessionID_;
+	private IQRouter iqRouter_;
+};
+
+public class DummyFileTransferTransporterFactory implements FileTransferTransporterFactory {
+
+	public DummyFileTransferTransporterFactory(
+		SOCKS5BytestreamRegistry s5bRegistry,
+		SOCKS5BytestreamServerManager s5bServerManager,
+		SOCKS5BytestreamProxiesManager s5bProxy,
+		IDGenerator idGenerator,
+		ConnectionFactory connectionFactory,
+		TimerFactory timerFactory,
+		CryptoProvider cryptoProvider,
+		IQRouter iqRouter) {
+		s5bRegistry_ = s5bRegistry;
+		s5bServerManager_ = s5bServerManager;
+		s5bProxy_ = s5bProxy;
+		idGenerator_ = idGenerator;
+		connectionFactory_ = connectionFactory;
+		timerFactory_ = timerFactory;
+		cryptoProvider_ = cryptoProvider;
+		iqRouter_ = iqRouter;
+	}
+
+	public FileTransferTransporter createInitiatorTransporter(final JID initiator, final JID responder, final FileTransferOptions options) {
+			DummyFileTransferTransporter transporter = new DummyFileTransferTransporter(
+				initiator,
+				responder,
+				DummyFileTransferTransporter.Role.Initiator,
+				s5bRegistry_,
+				s5bServerManager_,
+				s5bProxy_,
+				idGenerator_,
+				connectionFactory_,
+				timerFactory_,
+				cryptoProvider_,
+				iqRouter_,
+				options);
+			transporter.initialize();
+			return transporter;
+	}
+
+	public FileTransferTransporter createResponderTransporter(final JID initiator, final JID responder, final String s5bSessionID, final FileTransferOptions options) {
+		return null;
+	}
+
+	private SOCKS5BytestreamRegistry s5bRegistry_;
+	private SOCKS5BytestreamServerManager s5bServerManager_;
+	private SOCKS5BytestreamProxiesManager s5bProxy_;
+	private IDGenerator idGenerator_;
+	private ConnectionFactory connectionFactory_;
+	private TimerFactory timerFactory_;
+	private CryptoProvider cryptoProvider_;
+	private IQRouter iqRouter_;
+};
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FailingTransportSession.java b/src/com/isode/stroke/filetransfer/FailingTransportSession.java
new file mode 100644
index 0000000..b3cac2a
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FailingTransportSession.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+public class FailingTransportSession extends TransportSession {
+
+	public void start() {
+		assert(false);
+		onFinished.emit(new FileTransferError(FileTransferError.Type.PeerError));
+	}
+
+	public void stop() {
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileReadBytestream.java b/src/com/isode/stroke/filetransfer/FileReadBytestream.java
new file mode 100644
index 0000000..d349c17
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileReadBytestream.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import com.isode.stroke.base.ByteArray;
+
+public class FileReadBytestream extends ReadBytestream {
+
+	private String file;
+	private FileInputStream stream;
+
+	public FileReadBytestream(final String file) {
+		this.file = file;
+		this.stream = null;
+	}
+
+	public ByteArray read(int size) {
+		try {
+			if (stream == null) {
+				stream = new FileInputStream(file);
+			}
+			ByteArray result = new ByteArray();
+			//assert(stream.good());
+			stream.read(result.getData(), 0, size);
+			onRead.emit(result);
+			return result;
+		}
+		catch (FileNotFoundException e) {
+			return null;
+		}
+		catch (IOException e) {
+			return null;
+		} finally {
+			try {
+				if(stream != null) stream.close();
+			}
+			catch (IOException e) {
+				// Needs a catch clause
+			}
+		}
+	}
+
+	public boolean isFinished() {
+		return stream != null;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileTransfer.java b/src/com/isode/stroke/filetransfer/FileTransfer.java
new file mode 100644
index 0000000..8572d93
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransfer.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+
+/**
+ * Because of the lack of multiple inheritance in Java, this has to be done
+ * slightly differently from Swiften. What happens is that the methods in Swiften
+ * are provided abstract here. Any class implementing this interface directly/indirectly (through other interface) has to implement these methods.
+ * OutgoingJingleFileTransfer implements this interface indirectly through OutgoingFileTransfer.
+ * IncomingJingleFileTransfer implements this interface indirectly through IncomingFileTransfer.
+ * OutgoingSIFileTransfer implements this interface indirectly through OutgoingFileTransfer.
+ */
+public interface FileTransfer {
+
+	public static class State {
+		public enum Type {
+			Initial,
+			WaitingForStart,
+			Negotiating,
+			WaitingForAccept,
+			Transferring,
+			Canceled,
+			Failed,
+			Finished
+		};
+
+		public State(Type type) {
+			this(type, "");
+		}
+
+		public State(Type type, final String message) {
+			this.type = type;
+			this.message = message;
+		}
+
+		public Type type;
+		public String message = "";
+	};
+
+	public final Signal1<Integer /* proccessedBytes */> onProcessedBytes = new Signal1<Integer>();
+	public final Signal1<State> onStateChanged = new Signal1<State>();
+	public final Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+
+	public void cancel();
+
+	public String getFileName();
+
+	public long getFileSizeInBytes();
+
+	public void setFileInfo(final String name, long size);
+}
diff --git a/src/com/isode/stroke/filetransfer/FileTransferError.java b/src/com/isode/stroke/filetransfer/FileTransferError.java
new file mode 100644
index 0000000..ac135d6
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferError.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+public class FileTransferError {
+
+	private Type type;
+
+	public enum Type {
+		UnknownError,
+		PeerError,
+		ReadError,
+		ClosedError
+	};
+
+	public FileTransferError() {
+		this.type = Type.UnknownError;
+	}
+
+	public FileTransferError(Type type) {
+		this.type = type;
+	}
+
+	public Type getType() {
+		return type;
+	}
+}
diff --git a/src/com/isode/stroke/filetransfer/FileTransferManager.java b/src/com/isode/stroke/filetransfer/FileTransferManager.java
new file mode 100644
index 0000000..037514a
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferManager.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.elements.DiscoInfo;
+import java.util.Date;
+
+public abstract class FileTransferManager {
+
+	public abstract OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to, 
+			final String filepath, 
+			final String description, 
+			ReadBytestream bytestream,
+			final FileTransferOptions op);
+
+	public abstract OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to,
+			final String filename, 
+			final String description, 
+			final long sizeInBytes, 
+			final Date lastModified, 
+			ReadBytestream bytestream,
+			final FileTransferOptions op);
+			
+	public static boolean isSupportedBy(final DiscoInfo info) {
+		if (info != null) {
+			return info.hasFeature(DiscoInfo.JingleFeature)
+					&& info.hasFeature(DiscoInfo.JingleFTFeature)
+					&& (info.hasFeature(DiscoInfo.JingleTransportsIBBFeature) || info.hasFeature(DiscoInfo.JingleTransportsS5BFeature));
+		}
+		return false;
+	}
+
+	public final Signal1<IncomingFileTransfer> onIncomingFileTransfer = new Signal1<IncomingFileTransfer>();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileTransferManagerImpl.java b/src/com/isode/stroke/filetransfer/FileTransferManagerImpl.java
new file mode 100644
index 0000000..58ea74e
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferManagerImpl.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.ConnectionServerFactory;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.network.DomainNameResolver;
+import com.isode.stroke.disco.EntityCapsProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.jingle.JingleSessionManager;
+import com.isode.stroke.network.NATTraverser;
+import com.isode.stroke.network.NetworkEnvironment;
+import com.isode.stroke.presence.PresenceOracle;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.elements.DiscoInfo;
+import com.isode.stroke.elements.Presence;
+import com.isode.stroke.elements.JingleFileTransferFileInfo;
+import java.io.File;
+import java.util.Date;
+import java.util.TimeZone;
+import java.util.Vector;
+import java.util.Collection;
+
+public class FileTransferManagerImpl extends FileTransferManager {
+
+	private OutgoingFileTransferManager outgoingFTManager;
+	private IncomingFileTransferManager incomingFTManager;
+	private FileTransferTransporterFactory transporterFactory;
+	private IQRouter iqRouter;
+	private EntityCapsProvider capsProvider;
+	private PresenceOracle presenceOracle;
+	private IDGenerator idGenerator;
+	private SOCKS5BytestreamRegistry bytestreamRegistry;
+	private SOCKS5BytestreamProxiesManager bytestreamProxy;
+	private SOCKS5BytestreamServerManager s5bServerManager;
+
+	public FileTransferManagerImpl(
+			final JID ownJID, 
+			JingleSessionManager jingleSessionManager, 
+			IQRouter router, 
+			EntityCapsProvider capsProvider, 
+			PresenceOracle presOracle, 
+			ConnectionFactory connectionFactory,
+			ConnectionServerFactory connectionServerFactory,
+			TimerFactory timerFactory, 
+			DomainNameResolver domainNameResolver,
+			NetworkEnvironment networkEnvironment,
+			NATTraverser natTraverser,
+			CryptoProvider crypto) {
+		TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
+		this.iqRouter = router;
+		this.capsProvider = capsProvider;
+		this.presenceOracle = presOracle;
+		bytestreamRegistry = new SOCKS5BytestreamRegistry();
+		s5bServerManager = new SOCKS5BytestreamServerManager(bytestreamRegistry, connectionServerFactory, networkEnvironment, natTraverser);
+		bytestreamProxy = new SOCKS5BytestreamProxiesManager(connectionFactory, timerFactory, domainNameResolver, iqRouter, new JID(ownJID.getDomain()));
+
+		transporterFactory = new DefaultFileTransferTransporterFactory(
+				bytestreamRegistry,
+				s5bServerManager,
+				bytestreamProxy,
+				idGenerator,
+				connectionFactory, 
+				timerFactory, 
+				crypto,
+				iqRouter);
+		outgoingFTManager = new OutgoingFileTransferManager(
+				jingleSessionManager, 
+				iqRouter, 
+				transporterFactory,
+				timerFactory,
+				crypto);
+		incomingFTManager = new IncomingFileTransferManager(
+				jingleSessionManager, 
+				iqRouter, 
+				transporterFactory,
+				timerFactory,
+				crypto);
+		incomingFTManager.onIncomingFileTransfer.connect(onIncomingFileTransfer);
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to, 
+			final String filepath, 
+			final String description, 
+			ReadBytestream bytestream) {
+		return createOutgoingFileTransfer(to, filepath, description, bytestream, new FileTransferOptions());
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to, 
+			final String filepath, 
+			final String description, 
+			ReadBytestream bytestream,
+			final FileTransferOptions config) {
+		File file = new File(filepath);
+		String filename = file.getName();
+		long sizeInBytes = file.length();
+		Date lastModified = new Date(file.lastModified());
+		return createOutgoingFileTransfer(to, filename, description, sizeInBytes, lastModified, bytestream, config);
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to,
+			final String filename, 
+			final String description, 
+			final long sizeInBytes, 
+			final Date lastModified, 
+			ReadBytestream bytestream) {
+		return createOutgoingFileTransfer(to, filename, description, sizeInBytes, lastModified, bytestream, new FileTransferOptions());
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID to,
+			final String filename, 
+			final String description, 
+			final long sizeInBytes, 
+			final Date lastModified, 
+			ReadBytestream bytestream,
+			final FileTransferOptions config) {
+		JingleFileTransferFileInfo fileInfo = new JingleFileTransferFileInfo();
+		fileInfo.setDate(lastModified);
+		fileInfo.setSize(sizeInBytes);
+		fileInfo.setName(filename);
+		fileInfo.setDescription(description);
+		
+		JID receipient = to;
+		
+		if(receipient.isBare()) {
+			JID fullJID = highestPriorityJIDSupportingFileTransfer(receipient);
+			if (fullJID != null) {
+				receipient = fullJID;
+			} else {
+				return null;
+			}
+		}
+
+		assert(!iqRouter.getJID().isBare());
+
+		return outgoingFTManager.createOutgoingFileTransfer(iqRouter.getJID(), receipient, bytestream, fileInfo, config);
+	}
+
+	public void start() {
+
+	}
+
+	public void stop() {
+		s5bServerManager.stop();
+	}
+
+	private JID highestPriorityJIDSupportingFileTransfer(final JID bareJID) {
+		JID fullReceipientJID = new JID();
+		int priority = -2147483648;
+		
+		//getAllPresence(bareJID) gives you all presences for the bare JID (i.e. all resources) Isode Limited. @ 11:11
+		Collection<Presence> presences = presenceOracle.getAllPresence(bareJID);
+
+		//iterate over them
+		for(Presence pres : presences) {
+			if (pres.getPriority() > priority) {
+				// look up caps from the jid
+				DiscoInfo info = capsProvider.getCaps(pres.getFrom());
+				if (isSupportedBy(info)) {
+					priority = pres.getPriority();
+					fullReceipientJID = pres.getFrom();
+				}
+			}
+		}
+		
+		return fullReceipientJID.isValid() ? fullReceipientJID : null;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileTransferOptions.java b/src/com/isode/stroke/filetransfer/FileTransferOptions.java
new file mode 100644
index 0000000..fd529e9
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferOptions.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+public class FileTransferOptions {
+
+	private boolean allowInBand_;
+	private boolean allowAssisted_;
+	private boolean allowProxied_;
+	private boolean allowDirect_;
+
+	public FileTransferOptions() {
+		allowInBand_ = true;
+		allowAssisted_ = true;
+		allowProxied_ = true;
+		allowDirect_ = true;
+	}
+
+	public FileTransferOptions withInBandAllowed(boolean b) {
+		allowInBand_ = b;
+		return this;
+	}
+
+	public boolean isInBandAllowed() {
+		return allowInBand_;
+	}
+
+	public FileTransferOptions withAssistedAllowed(boolean b) {
+		allowAssisted_ = b;
+		return this;
+	}
+
+	public boolean isAssistedAllowed() {
+		return allowAssisted_;
+	}
+
+	public FileTransferOptions withProxiedAllowed(boolean b) {
+		allowProxied_ = b;
+		return this;
+	}
+
+	public boolean isProxiedAllowed() {
+		return allowProxied_;
+	}
+
+	public FileTransferOptions withDirectAllowed(boolean b) {
+		allowDirect_ = b;
+		return this;
+	}
+
+	public boolean isDirectAllowed() {
+		return allowDirect_;
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileTransferTransporter.java b/src/com/isode/stroke/filetransfer/FileTransferTransporter.java
new file mode 100644
index 0000000..d20550d
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferTransporter.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.signals.Signal2;
+import com.isode.stroke.signals.Signal3;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+
+/**
+ * @brief The FileTransferTransporter class is an abstract factory definition
+ * to generate SOCKS5 bytestream transports or IBB bytestreams for use in file
+ * transfers.
+ */
+public abstract class FileTransferTransporter {
+
+	public abstract void startGeneratingLocalCandidates();
+	public abstract void stopGeneratingLocalCandidates();
+
+	public abstract void addRemoteCandidates(
+					final Vector<JingleS5BTransportPayload.Candidate> c, final String s);
+	public abstract void startTryingRemoteCandidates();
+	public abstract void stopTryingRemoteCandidates();
+
+	public abstract void startActivatingProxy(final JID proxy);
+	public abstract void stopActivatingProxy();
+
+	public abstract TransportSession createIBBSendSession(
+					final String sessionID, int blockSize, ReadBytestream r);
+	public abstract TransportSession createIBBReceiveSession(
+					final String sessionID, int size, WriteBytestream w);
+	public abstract TransportSession createRemoteCandidateSession(
+					ReadBytestream r, final JingleS5BTransportPayload.Candidate candidate);
+	public abstract TransportSession createRemoteCandidateSession(
+					WriteBytestream w, final JingleS5BTransportPayload.Candidate candidate);
+	public abstract TransportSession createLocalCandidateSession(
+					ReadBytestream r, final JingleS5BTransportPayload.Candidate candidate);
+	public abstract TransportSession createLocalCandidateSession(
+					WriteBytestream w, final JingleS5BTransportPayload.Candidate candidate);
+
+	public final Signal3<String /* sessionID */, Vector<JingleS5BTransportPayload.Candidate>, String /* dstAddr */> onLocalCandidatesGenerated = new Signal3<String, Vector<JingleS5BTransportPayload.Candidate>, String>();
+	public final Signal2<String /* sessionID */, JingleS5BTransportPayload.Candidate> onRemoteCandidateSelectFinished = new Signal2<String, JingleS5BTransportPayload.Candidate>();
+	public final Signal2<String /* sessionID */, ErrorPayload> onProxyActivated = new Signal2<String, ErrorPayload>();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/FileTransferTransporterFactory.java b/src/com/isode/stroke/filetransfer/FileTransferTransporterFactory.java
new file mode 100644
index 0000000..5eb3286
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/FileTransferTransporterFactory.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+
+public interface FileTransferTransporterFactory {
+
+	public FileTransferTransporter createInitiatorTransporter(
+		final JID initiator, 
+		final JID responder,
+		final FileTransferOptions options);
+	public FileTransferTransporter createResponderTransporter(
+		final JID initiator, 
+		final JID responder, 
+		final String s5bSessionID,
+		final FileTransferOptions options);
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IBBReceiveSession.java b/src/com/isode/stroke/filetransfer/IBBReceiveSession.java
new file mode 100644
index 0000000..d5e831a
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IBBReceiveSession.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.queries.SetResponder;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.elements.IBB;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.signals.Signal1;
+import java.util.logging.Logger;
+
+public class IBBReceiveSession {
+
+	class IBBResponder extends SetResponder<IBB> {
+
+		public IBBResponder(IBBReceiveSession session, IQRouter router) {
+			super(new IBB(), router);
+			this.session = session;
+			this.sequenceNumber = 0;
+			this.receivedSize = 0;
+			setFinal(false);
+		}
+
+		public boolean handleSetRequest(final JID from, final JID to, final String id, IBB ibb) {
+			if (from.equals(session.from) && ibb.getStreamID().equals(session.id)) {
+				if (IBB.Action.Data.equals(ibb.getAction())) {
+					if (sequenceNumber == ibb.getSequenceNumber()) {
+						session.bytestream.write(ibb.getData());
+						receivedSize += ibb.getData().getSize();
+						sequenceNumber++;
+						sendResponse(from, id, null);
+						if (receivedSize >= session.size) {
+							if (receivedSize > session.size) {
+								logger_.warning("Received more data than expected");
+							}
+							session.finish(null);
+						}
+					}
+					else {
+						logger_.warning("Received data out of order");
+						sendError(from, id, ErrorPayload.Condition.NotAcceptable, ErrorPayload.Type.Cancel);
+						session.finish(new FileTransferError(FileTransferError.Type.ClosedError));
+					}
+				}
+				else if (IBB.Action.Open.equals(ibb.getAction())) {
+					logger_.fine("IBB open received");
+					sendResponse(from, id, null);
+				}
+				else if (IBB.Action.Close.equals(ibb.getAction())) {
+					logger_.fine("IBB close received");
+					sendResponse(from, id, null);
+					session.finish(new FileTransferError(FileTransferError.Type.ClosedError));
+				}
+				return true;
+			}
+			logger_.fine("wrong from/sessionID: " + from + " == " + session.from + " / " + ibb.getStreamID() + " == " + session.id);
+			return false;
+		}
+
+		private IBBReceiveSession session;
+		private int sequenceNumber;
+		private long receivedSize;
+		private Logger logger_ = Logger.getLogger(this.getClass().getName());
+	};
+
+	private String id = "";
+	private JID from = new JID();
+	private JID to = new JID();
+	private long size;
+	private WriteBytestream bytestream;
+	private IQRouter router;
+	private IBBResponder responder;
+	private boolean active;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public IBBReceiveSession(final String id, final JID from, final JID to, long size, WriteBytestream bytestream, IQRouter router) {
+		this.id = id; 
+		this.from = from; 
+		this.to = to;
+		this.size = size; 
+		this.bytestream = bytestream;
+		this.router = router;
+		this.active = false;
+		assert(!id.isEmpty());
+		assert(from.isValid());
+		responder = new IBBResponder(this, router);
+	}
+	
+	public void start() {
+		logger_.fine("receive session started");
+		active = true;
+		responder.start();
+	}
+
+	public void stop() {
+		logger_.fine("receive session stopped");
+		responder.stop();
+		if (active) {
+			if (router.isAvailable()) {
+				IBBRequest.create(to, from, IBB.createIBBClose(id), router).send();
+			}
+			finish(null);
+		}
+	}
+
+	public JID getSender() {
+		return from;
+	}
+
+	public JID getReceiver() {
+		return to;
+	}
+
+	public final Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+
+	private void finish(FileTransferError error) {
+		active = false;
+		onFinished.emit(error);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IBBReceiveTransportSession.java b/src/com/isode/stroke/filetransfer/IBBReceiveTransportSession.java
new file mode 100644
index 0000000..9a494a4
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IBBReceiveTransportSession.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.SignalConnection;
+
+public class IBBReceiveTransportSession extends TransportSession {
+
+	private IBBReceiveSession session;
+	private SignalConnection finishedConnection;
+	private SignalConnection bytesSentConnection;
+
+	public IBBReceiveTransportSession(IBBReceiveSession session) {
+		this.session = session;
+		finishedConnection = session.onFinished.connect(onFinished);
+	}
+
+	public void start() {
+		session.start();
+	}
+
+	public void stop() {
+		session.stop();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IBBRequest.java b/src/com/isode/stroke/filetransfer/IBBRequest.java
new file mode 100644
index 0000000..54fbbd6
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IBBRequest.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.elements.IBB;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.jid.JID;
+
+public class IBBRequest extends GenericRequest<IBB> {
+
+	public static IBBRequest create(final JID from, final JID to, IBB payload, IQRouter router) {
+		return new IBBRequest(from, to, payload, router);
+	}
+
+	private IBBRequest(final JID from, final JID to, IBB payload, IQRouter router) {
+		super(IQ.Type.Set, from, to, payload, router);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IBBSendSession.java b/src/com/isode/stroke/filetransfer/IBBSendSession.java
new file mode 100644
index 0000000..5a812ff
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IBBSendSession.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2010-2013 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.signals.Slot;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.elements.IBB;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.base.ByteArray;
+
+public class IBBSendSession {
+
+	private String id = "";
+	private JID from = new JID();
+	private JID to = new JID();
+	private ReadBytestream bytestream;
+	private IQRouter router;
+	private int blockSize;
+	private int sequenceNumber;
+	private boolean active;
+	private boolean waitingForData;
+
+	public IBBSendSession(final String id, final JID from, final JID to, ReadBytestream bytestream, IQRouter router) {
+		this.id = id; 
+		this.from = from; 
+		this.to = to; 
+		this.bytestream = bytestream;
+		this.router = router; 
+		this.blockSize = 4096; 
+		this.sequenceNumber = 0; 
+		this.active = false; 
+		this.waitingForData = false;
+		bytestream.onDataAvailable.connect(new Slot() {
+			@Override
+			public void call() {
+				handleDataAvailable();
+			}
+		});
+	}
+
+	public void start() {
+		IBBRequest request = IBBRequest.create(from, to, IBB.createIBBOpen(id, (int)(blockSize)), router);
+		request.onResponse.connect(new Slot2<IBB, ErrorPayload>() {
+			@Override
+			public void call(IBB b, ErrorPayload e) {
+				handleIBBResponse(b, e);
+			}
+		});
+		active = true;
+		request.send();
+	}
+
+	public void stop() {
+		if (active && router.isAvailable()) {
+			IBBRequest.create(from, to, IBB.createIBBClose(id), router).send();
+		}
+		finish(null);
+	}
+
+	public JID getSender() {
+		return from;
+	}
+
+	public JID getReceiver() {
+		return to;
+	}
+
+	public void setBlockSize(int blockSize) {
+		this.blockSize = blockSize;
+	}
+
+	public final Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+	public final Signal1<Integer> onBytesSent = new Signal1<Integer>();
+
+	private void handleIBBResponse(IBB ibb, ErrorPayload error) {
+		if (error == null && active) {
+			if (!bytestream.isFinished()) {
+				sendMoreData();
+			}
+			else {
+				finish(null);
+			}
+		}
+		else {
+			finish(new FileTransferError(FileTransferError.Type.PeerError));
+		}		
+	}
+	private void finish(FileTransferError error) {
+		active = false;
+		onFinished.emit(error);
+	}
+
+	private void sendMoreData() {
+		//try {
+			ByteArray data = bytestream.read(blockSize);
+			if (!data.isEmpty()) {
+				waitingForData = false;
+				IBBRequest request = IBBRequest.create(from, to, IBB.createIBBData(id, sequenceNumber, data), router);
+				sequenceNumber++;
+				request.onResponse.connect(new Slot2<IBB, ErrorPayload>() {
+					@Override
+					public void call(IBB b, ErrorPayload e) {
+						handleIBBResponse(b, e);
+					}
+				});
+				request.send();
+				onBytesSent.emit(data.getSize());
+			}
+			else {
+				waitingForData = true;
+			}
+		//}
+		//catch (BytestreamException e) {
+		//	finish(new FileTransferError(FileTransferError.Type.ReadError));
+		//}		
+	}
+
+	private void handleDataAvailable() {
+		if (waitingForData) {
+			sendMoreData();
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IBBSendTransportSession.java b/src/com/isode/stroke/filetransfer/IBBSendTransportSession.java
new file mode 100644
index 0000000..a37ce38
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IBBSendTransportSession.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.SignalConnection;
+
+public class IBBSendTransportSession extends TransportSession {
+
+	private IBBSendSession session;
+	private SignalConnection finishedConnection;
+	private SignalConnection bytesSentConnection;
+
+	public IBBSendTransportSession(IBBSendSession session) {
+		this.session = session;
+		finishedConnection = session.onFinished.connect(onFinished);
+		bytesSentConnection = session.onBytesSent.connect(onBytesSent);
+	}
+
+	public void start() {
+		session.start();
+	}
+
+	public void stop() {
+		session.stop();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IncomingFileTransfer.java b/src/com/isode/stroke/filetransfer/IncomingFileTransfer.java
new file mode 100644
index 0000000..53c29a4
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IncomingFileTransfer.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+
+/**
+ * Because of the lack of multiple inheritance in Java, this has to be done
+ * slightly differently from Swiften. What happens is that the methods in Swiften
+ * are provided abstract here. Any class implementing this interface directly/indirectly (through other interface) has to implement these methods.
+ * IncomingJingleFileTransfer implements this interface and will also need to implement methods from FileTransfer (which is an interface).
+ * @brief The IncomingFileTransfer interface is the general interface in Swiften
+ * for incoming file transfers.
+ */
+public interface IncomingFileTransfer extends FileTransfer {
+
+	public void accept(WriteBytestream w);
+	public void accept(WriteBytestream w, final FileTransferOptions options);
+
+	public JID getSender();
+	public JID getRecipient();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IncomingFileTransferManager.java b/src/com/isode/stroke/filetransfer/IncomingFileTransferManager.java
new file mode 100644
index 0000000..ffdf86e
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IncomingFileTransferManager.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.jingle.IncomingJingleSessionHandler;
+import com.isode.stroke.jingle.JingleSessionManager;
+import com.isode.stroke.jingle.JingleSession;
+import com.isode.stroke.elements.JinglePayload;
+import com.isode.stroke.elements.JingleContentPayload;
+import com.isode.stroke.elements.JingleFileTransferDescription;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.jingle.Jingle;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.jid.JID;
+import java.util.logging.Logger;
+import java.util.Vector;
+
+public class IncomingFileTransferManager implements IncomingJingleSessionHandler {
+
+	private JingleSessionManager jingleSessionManager;
+	private IQRouter router;
+	private FileTransferTransporterFactory transporterFactory;
+	private TimerFactory timerFactory;
+	private CryptoProvider crypto;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public IncomingFileTransferManager(
+			JingleSessionManager jingleSessionManager, 
+			IQRouter router, 
+			FileTransferTransporterFactory transporterFactory,
+			TimerFactory timerFactory, 
+			CryptoProvider crypto) {
+		this.jingleSessionManager = jingleSessionManager;
+		this.router = router;
+		this.transporterFactory = transporterFactory;
+		this.timerFactory = timerFactory;
+		this.crypto = crypto;
+		jingleSessionManager.addIncomingSessionHandler(this);
+	}
+
+	public Signal1<IncomingFileTransfer> onIncomingFileTransfer = new Signal1<IncomingFileTransfer>();
+
+	public boolean handleIncomingJingleSession(
+			JingleSession session, 
+			final Vector<JingleContentPayload> contents, 
+			final JID recipient) {
+		if (Jingle.getContentWithDescription(contents, new JingleFileTransferDescription()) != null) {
+			JingleContentPayload content = Jingle.getContentWithDescription(contents, new JingleFileTransferDescription());
+			if (content.getTransport(new JingleS5BTransportPayload()) != null) {
+				JingleFileTransferDescription description = content.getDescription(new JingleFileTransferDescription());
+				if (description != null) {
+					IncomingJingleFileTransfer transfer = new IncomingJingleFileTransfer(
+							recipient, session, content, transporterFactory, timerFactory, crypto);
+					onIncomingFileTransfer.emit(transfer);
+				} 
+				else {
+					logger_.warning("Received a file-transfer request with no file description.");
+					session.sendTerminate(JinglePayload.Reason.Type.FailedApplication);
+				}
+			}
+			else {
+				session.sendTerminate(JinglePayload.Reason.Type.UnsupportedTransports);
+			}
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IncomingJingleFileTransfer.java b/src/com/isode/stroke/filetransfer/IncomingJingleFileTransfer.java
new file mode 100644
index 0000000..c5001e0
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IncomingJingleFileTransfer.java
@@ -0,0 +1,500 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.jingle.JingleSession;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.network.Timer;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.base. ByteArray;
+import com.isode.stroke.elements.JingleFileTransferFileInfo;
+import com.isode.stroke.elements.JingleDescription;
+import com.isode.stroke.elements.JingleTransportPayload;
+import com.isode.stroke.elements.JingleIBBTransportPayload;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.elements.JinglePayload;
+import com.isode.stroke.elements.JingleContentPayload;
+import com.isode.stroke.elements.JingleFileTransferDescription;
+import com.isode.stroke.elements.HashElement;
+import com.isode.stroke.elements.JingleFileTransferHash;
+import com.isode.stroke.jingle.JingleContentID;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot;
+import java.util.logging.Logger;
+import java.util.Vector;
+import java.util.Map;
+import java.util.HashMap;
+
+public class IncomingJingleFileTransfer extends JingleFileTransfer implements IncomingFileTransfer {
+
+	private long fileSizeInBytes = 0; //FileTransferVariables
+	private String filename = ""; //FileTransferVariables
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public String getFileName() {
+		return filename;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public long getFileSizeInBytes() {
+		return fileSizeInBytes;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public void setFileInfo(final String name, long size) {
+		this.filename = name;
+		this.fileSizeInBytes = size;
+	}
+
+	private JingleContentPayload initialContent;
+	private CryptoProvider crypto;
+	private State state;
+	private JingleFileTransferDescription description;
+	private WriteBytestream stream;
+	private long receivedBytes;
+	private IncrementalBytestreamHashCalculator hashCalculator;
+	private Timer waitOnHashTimer;
+	private Map<String, ByteArray> hashes = new HashMap<String, ByteArray>();
+	private FileTransferOptions options;
+
+	private SignalConnection writeStreamDataReceivedConnection;
+	private SignalConnection waitOnHashTimerTickedConnection;
+	private SignalConnection transferFinishedConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public IncomingJingleFileTransfer(
+		final JID toJID,
+		JingleSession session,
+		JingleContentPayload content,
+		FileTransferTransporterFactory transporterFactory,
+		TimerFactory timerFactory,
+		CryptoProvider crypto) {
+		super(session, toJID, transporterFactory);
+		this.initialContent = content;
+		this.crypto = crypto;
+		this.state = State.Initial;
+		this. receivedBytes = 0;
+		this.hashCalculator = null;
+		this.description = initialContent.getDescription(new JingleFileTransferDescription());
+		assert(description != null);
+		JingleFileTransferFileInfo fileInfo = description.getFileInfo();
+		setFileInfo(fileInfo.getName(), fileInfo.getSize());
+		hashes = fileInfo.getHashes();
+
+		waitOnHashTimer = timerFactory.createTimer(5000);
+		waitOnHashTimerTickedConnection = waitOnHashTimer.onTick.connect(new Slot() {
+			@Override
+			public void call() {
+				handleWaitOnHashTimerTicked();
+			}
+		});
+	}
+
+	/**
+	* IncomingFileTransferMethod.
+	*/
+	@Override
+	public void accept(WriteBytestream stream) {
+		accept(stream, new FileTransferOptions());
+	}
+
+	/**
+	* IncomingFileTransferMethod.
+	*/
+	@Override
+	public void accept(WriteBytestream stream, final FileTransferOptions options) {
+		logger_.fine("\n");
+		if (!State.Initial.equals(state)) { logger_.warning("Incorrect state \n"); return; }
+
+		assert(this.stream == null);
+		this.stream = stream;
+		this.options = options;
+
+		assert(hashCalculator == null);
+
+		hashCalculator = new IncrementalBytestreamHashCalculator(hashes.containsKey("md5"), hashes.containsKey("sha-1"), crypto);
+
+		writeStreamDataReceivedConnection = stream.onWrite.connect(new Slot1<ByteArray>() {
+			@Override
+			public void call(ByteArray b) {
+				handleWriteStreamDataReceived(b);
+			}
+		});
+
+		if (initialContent.getTransport(new JingleS5BTransportPayload()) != null) {
+			JingleS5BTransportPayload s5bTransport = initialContent.getTransport(new JingleS5BTransportPayload());
+			logger_.fine("Got S5B transport as initial payload.\n");
+			setTransporter(transporterFactory.createResponderTransporter(getInitiator(), getResponder(), s5bTransport.getSessionID(), options));
+			transporter.addRemoteCandidates(s5bTransport.getCandidates(), s5bTransport.getDstAddr());
+			setState(State.GeneratingInitialLocalCandidates);
+			transporter.startGeneratingLocalCandidates();
+		}
+		else if(initialContent.getTransport(new JingleIBBTransportPayload()) != null) {
+			JingleIBBTransportPayload ibbTransport = initialContent.getTransport(new JingleIBBTransportPayload());
+			logger_.fine("Got IBB transport as initial payload.\n");
+			setTransporter(transporterFactory.createResponderTransporter(getInitiator(), getResponder(), ibbTransport.getSessionID(), options));
+
+			startTransferring(transporter.createIBBReceiveSession(ibbTransport.getSessionID(), (int)description.getFileInfo().getSize(), stream));
+
+			session.sendAccept(getContentID(), initialContent.getDescriptions().get(0), ibbTransport);
+		}
+		else {
+			// Can't happen, because the transfer would have been rejected automatically
+			assert(false);
+		}
+	}
+
+	/**
+	* IncomingFileTransferMethod.
+	*/
+	@Override
+	public JID getSender() {
+		return getInitiator();
+	}
+
+	/**
+	* IncomingFileTransferMethod.
+	*/
+	@Override
+	public JID getRecipient() {
+		return getResponder();
+	}
+
+	/**
+	* JingleFileTransferMethod.
+	*/
+	@Override
+	public void cancel() {
+		logger_.fine("\n");
+		terminate(State.Initial.equals(state) ? JinglePayload.Reason.Type.Decline : JinglePayload.Reason.Type.Cancel);
+	}
+
+	protected void startTransferViaRemoteCandidate() {
+		logger_.fine("\n");
+
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(ourCandidateChoice.type)) {
+			setState(State.WaitingForPeerProxyActivate);
+		} 
+		else {
+			startTransferring(createRemoteCandidateSession());
+		}
+	}
+
+	protected void startTransferViaLocalCandidate() {
+		logger_.fine("\n");
+
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(theirCandidateChoice.type)) {
+			setState(State.WaitingForLocalProxyActivate);
+			transporter.startActivatingProxy(theirCandidateChoice.jid);
+		} 
+		else {
+			startTransferring(createLocalCandidateSession());
+		}
+	}
+	
+	protected void checkHashAndTerminate() {
+		if (verifyData()) {
+			terminate(JinglePayload.Reason.Type.Success);
+		}
+		else {
+			logger_.warning("Hash verification failed\n");
+			terminate(JinglePayload.Reason.Type.MediaError);
+		}
+	}
+
+	protected void stopAll() {
+		if (!State.Initial.equals(state)) {
+			writeStreamDataReceivedConnection.disconnect();
+			hashCalculator = null;
+		}
+		switch (state) {
+			case Initial: break;
+			case GeneratingInitialLocalCandidates: transporter.stopGeneratingLocalCandidates(); break;
+			case TryingCandidates: transporter.stopTryingRemoteCandidates(); break;
+			case WaitingForFallbackOrTerminate: break;
+			case WaitingForPeerProxyActivate: break;
+			case WaitingForLocalProxyActivate: transporter.stopActivatingProxy(); break;
+			case WaitingForHash: // Fallthrough
+			case Transferring:
+				assert(transportSession != null);
+				transferFinishedConnection.disconnect();
+				transportSession.stop();
+				transportSession = null;
+				break;
+			case Finished: logger_.warning("Already finished\n"); break;
+		}
+		if (!State.Initial.equals(state)) {
+			removeTransporter();
+		}
+	}
+
+	protected void setState(State state) {
+		logger_.fine(state + "\n");
+		this.state = state;
+		onStateChanged.emit(new FileTransfer.State(getExternalState(state)));
+	}
+
+	protected void setFinishedState(FileTransfer.State.Type type, final FileTransferError error) {
+		logger_.fine("\n");
+		this.state = State.Finished;
+		onStateChanged.emit(new FileTransfer.State(type));
+		onFinished.emit(error);
+	}
+
+	protected static FileTransfer.State.Type getExternalState(State state) {
+		switch (state) {
+			case Initial: return FileTransfer.State.Type.Initial;
+			case GeneratingInitialLocalCandidates: return FileTransfer.State.Type.WaitingForStart;
+			case TryingCandidates: return FileTransfer.State.Type.Negotiating;
+			case WaitingForPeerProxyActivate: return FileTransfer.State.Type.Negotiating;
+			case WaitingForLocalProxyActivate: return FileTransfer.State.Type.Negotiating;
+			case WaitingForFallbackOrTerminate: return FileTransfer.State.Type.Negotiating;
+			case Transferring: return FileTransfer.State.Type.Transferring;
+			case WaitingForHash: return FileTransfer.State.Type.Transferring;
+			case Finished: return FileTransfer.State.Type.Finished;
+		}
+		assert(false);
+		return FileTransfer.State.Type.Initial;
+	}
+
+	protected boolean hasPriorityOnCandidateTie() {
+		return false;
+	}
+
+	protected void fallback() {
+		setState(State.WaitingForFallbackOrTerminate);
+	}
+
+	protected void startTransferring(TransportSession transportSession) {
+		logger_.fine("\n");
+
+		this.transportSession = transportSession;
+		transferFinishedConnection = transportSession.onFinished.connect(new Slot1<FileTransferError>() {
+			@Override
+			public void call(FileTransferError e) {
+				handleTransferFinished(e);
+			}
+		});
+		setState(State.Transferring);
+		transportSession.start();
+	}
+
+	protected boolean isWaitingForPeerProxyActivate() {
+		return State.WaitingForPeerProxyActivate.equals(state);
+	}
+
+	protected boolean isWaitingForLocalProxyActivate() {
+		return State.WaitingForLocalProxyActivate.equals(state);
+	}
+
+	protected boolean isTryingCandidates() {
+		return State.TryingCandidates.equals(state);
+	}
+
+	protected TransportSession createLocalCandidateSession() {
+		return transporter.createLocalCandidateSession(stream, theirCandidateChoice);
+	}
+
+	protected TransportSession createRemoteCandidateSession() {
+		return transporter.createRemoteCandidateSession(stream, ourCandidateChoice);
+	}
+
+	protected void terminate(JinglePayload.Reason.Type reason) {
+		logger_.fine(reason + "\n");
+
+		if (!State.Finished.equals(state)) {
+			session.sendTerminate(reason);
+		}
+		stopAll();
+		setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));
+	}
+
+	private enum State {
+		Initial,
+		GeneratingInitialLocalCandidates,	
+		TryingCandidates,
+		WaitingForPeerProxyActivate,
+		WaitingForLocalProxyActivate,
+		WaitingForFallbackOrTerminate,
+		Transferring,
+		WaitingForHash,
+		Finished
+	};
+
+	public void handleSessionTerminateReceived(JinglePayload.Reason reason) {
+		logger_.fine("\n");
+		if (State.Finished.equals(state)) { logger_.warning("Incorrect state\n"); return; }
+
+		if (State.Finished.equals(state)) { 
+			logger_.fine("Already terminated\n");
+			return; 
+		}
+
+		stopAll();
+		if (reason != null && JinglePayload.Reason.Type.Cancel.equals(reason.type)) {
+			setFinishedState(FileTransfer.State.Type.Canceled, new FileTransferError(FileTransferError.Type.PeerError));
+		}
+		else if (reason != null && JinglePayload.Reason.Type.Success.equals(reason.type)) {
+			setFinishedState(FileTransfer.State.Type.Finished, null);
+		} 
+		else {
+			setFinishedState(FileTransfer.State.Type.Failed, new FileTransferError(FileTransferError.Type.PeerError));
+		}
+	}
+
+	public void handleSessionInfoReceived(JinglePayload jinglePayload) {
+		logger_.fine("\n");
+
+		JingleFileTransferHash transferHash = jinglePayload.getPayload(new JingleFileTransferHash());
+		if (transferHash != null) {
+			logger_.fine("Received hash information.\n");
+			waitOnHashTimer.stop();
+			if (transferHash.getFileInfo().getHashes().containsKey("sha-1")) {
+				hashes.put("sha-1", transferHash.getFileInfo().getHash("sha-1"));
+			}
+			if (transferHash.getFileInfo().getHashes().containsKey("md5")) {
+				hashes.put("md5", transferHash.getFileInfo().getHash("md5"));
+			}
+			if (State.WaitingForHash.equals(state)) {
+				checkHashAndTerminate();
+			}
+		}
+		else {
+			logger_.fine("Ignoring unknown session info\n");
+		}
+	}
+
+	public void handleTransportReplaceReceived(final JingleContentID content, JingleTransportPayload transport) {
+		logger_.fine("\n");
+		if (!State.WaitingForFallbackOrTerminate.equals(state)) { 
+			logger_.warning("Incorrect state\n"); 
+			return; 
+		}
+
+		JingleIBBTransportPayload ibbTransport;
+		if (options.isInBandAllowed() && transport instanceof JingleIBBTransportPayload) {
+			ibbTransport = (JingleIBBTransportPayload)transport;
+			logger_.fine("transport replaced with IBB\n");
+
+			startTransferring(transporter.createIBBReceiveSession(ibbTransport.getSessionID(), (int)description.getFileInfo().getSize(), stream));
+			session.sendTransportAccept(content, ibbTransport);
+		} 
+		else {
+			logger_.fine("Unknown replace transport\n");
+			session.sendTransportReject(content, transport);
+		}
+	}
+
+	protected void handleLocalTransportCandidatesGenerated(final String s5bSessionID, final Vector<JingleS5BTransportPayload.Candidate> candidates, final String dstAddr) {
+		logger_.fine("\n");
+		if (!State.GeneratingInitialLocalCandidates.equals(state)) { logger_.warning("Incorrect state\n"); return; }
+
+		fillCandidateMap(localCandidates, candidates);
+
+		JingleS5BTransportPayload transport = new JingleS5BTransportPayload();
+		transport.setSessionID(s5bSessionID);
+		transport.setMode(JingleS5BTransportPayload.Mode.TCPMode);
+		transport.setDstAddr(dstAddr);
+		for(JingleS5BTransportPayload.Candidate candidate : candidates) {
+			transport.addCandidate(candidate);	
+		}
+		session.sendAccept(getContentID(), initialContent.getDescriptions().get(0), transport);
+
+		setState(State.TryingCandidates);
+		transporter.startTryingRemoteCandidates();
+	}
+
+	private void handleWriteStreamDataReceived(final ByteArray data) {
+		hashCalculator.feedData(data);
+		receivedBytes += data.getSize();
+		onProcessedBytes.emit(data.getSize());
+		checkIfAllDataReceived();
+	}
+
+	private void stopActiveTransport() {
+
+	}
+
+	private void checkCandidateSelected() {
+
+	}
+
+	protected JingleContentID getContentID() {
+		return new JingleContentID(initialContent.getName(), initialContent.getCreator());
+	}
+
+	private void checkIfAllDataReceived() {
+		if (receivedBytes == getFileSizeInBytes()) {
+			logger_.fine("All data received.\n");
+			boolean hashInfoAvailable = false;
+			for(final Map.Entry<String, ByteArray> hashElement : hashes.entrySet()) {
+				hashInfoAvailable |= !(hashElement.getValue().isEmpty());
+			}
+
+			if (!hashInfoAvailable) {
+				logger_.fine("No hash information yet. Waiting a while on hash info.\n");
+				setState(State.WaitingForHash);
+				waitOnHashTimer.start();
+			} 
+			else {
+				checkHashAndTerminate();
+			}
+		}
+		else if (receivedBytes > getFileSizeInBytes()) {
+			logger_.fine("We got more than we could handle!\n");
+			terminate(JinglePayload.Reason.Type.MediaError);
+		}
+	}
+
+	private boolean verifyData() {
+		if (hashes.isEmpty()) {
+			logger_.fine("no verification possible, skipping\n");
+			return true;
+		} 
+		if (hashes.containsKey("sha-1")) {
+			logger_.fine("Verify SHA-1 hash: " + (hashes.get("sha-1").equals(hashCalculator.getSHA1Hash())) + "\n");
+			return hashes.get("sha-1").equals(hashCalculator.getSHA1Hash());
+		}
+		else if (hashes.containsKey("md5")) {
+			logger_.fine("Verify MD5 hash: " + (hashes.get("md5").equals(hashCalculator.getMD5Hash())) + "\n");
+			return hashes.get("md5").equals(hashCalculator.getMD5Hash());
+		}
+		else {
+			logger_.fine("Unknown hash, skipping\n");
+			return true;
+		}
+	}
+
+	private void handleWaitOnHashTimerTicked() {
+		logger_.fine("\n");
+		waitOnHashTimer.stop();
+		terminate(JinglePayload.Reason.Type.Success);
+	}
+
+	private void handleTransferFinished(FileTransferError error) {
+		if (error != null && !State.WaitingForHash.equals(state)) {
+			terminate(JinglePayload.Reason.Type.MediaError);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/IncrementalBytestreamHashCalculator.java b/src/com/isode/stroke/filetransfer/IncrementalBytestreamHashCalculator.java
new file mode 100644
index 0000000..e79a7a5
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/IncrementalBytestreamHashCalculator.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2014 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.crypto.Hash;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.base.ByteArray;
+import com.isode.stroke.stringcodecs.Hexify;
+
+public class IncrementalBytestreamHashCalculator {
+
+	private Hash md5Hasher;
+	private Hash sha1Hasher;
+	private ByteArray md5Hash;
+	private ByteArray sha1Hash;
+
+	public IncrementalBytestreamHashCalculator(boolean doMD5, boolean doSHA1, CryptoProvider crypto) {
+		md5Hasher = doMD5 ? crypto.createMD5() : null;
+		sha1Hasher = doSHA1 ? crypto.createSHA1() : null;
+	}
+
+	public void feedData(final ByteArray data) {
+		if (md5Hasher != null) {
+			md5Hasher.update(data);
+		}
+		if (sha1Hasher != null) {
+			sha1Hasher.update(data);
+		}
+	}
+
+	/*void feedData(const SafeByteArray& data) {
+		if (md5Hasher) {
+			md5Hasher.update(createByteArray(data.data(), data.size()));
+		}
+		if (sha1Hasher) {
+			sha1Hasher.update(createByteArray(data.data(), data.size()));
+		}
+	}*/
+
+	public ByteArray getSHA1Hash() {
+		assert(sha1Hasher != null);
+		if (sha1Hash == null) {
+			sha1Hash = sha1Hasher.getHash();
+		}
+		return sha1Hash;
+	}
+
+	public ByteArray getMD5Hash() {
+		assert(md5Hasher != null);
+		if (md5Hash == null) {
+			md5Hash = md5Hasher.getHash();
+		}
+		return md5Hash;
+	}
+
+	public String getSHA1String() {
+		assert(sha1Hasher != null);
+		return Hexify.hexify(getSHA1Hash());
+	}
+
+	public String getMD5String() {
+		assert(md5Hasher != null);
+		return Hexify.hexify(getMD5Hash());	
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/JingleFileTransfer.java b/src/com/isode/stroke/filetransfer/JingleFileTransfer.java
new file mode 100644
index 0000000..b70c11a
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/JingleFileTransfer.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.jingle.JingleSession;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.elements.JingleTransportPayload;
+import com.isode.stroke.elements.JinglePayload;
+import com.isode.stroke.jingle.JingleContentID;
+import com.isode.stroke.jingle.AbstractJingleSessionListener;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot3;
+import com.isode.stroke.signals.Slot2;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Vector;
+import java.util.logging.Logger;
+
+public abstract class JingleFileTransfer extends AbstractJingleSessionListener {
+
+	protected JingleSession session;
+	protected JID target;
+	protected FileTransferTransporterFactory transporterFactory;
+	protected FileTransferTransporter transporter;
+
+	protected String candidateSelectRequestID;
+	protected boolean ourCandidateSelectFinished;
+	protected JingleS5BTransportPayload.Candidate ourCandidateChoice;
+	protected boolean theirCandidateSelectFinished;
+	protected JingleS5BTransportPayload.Candidate theirCandidateChoice;
+	protected Map<String, JingleS5BTransportPayload.Candidate> localCandidates = new HashMap<String, JingleS5BTransportPayload.Candidate>();
+
+	protected TransportSession transportSession;
+
+	protected SignalConnection localTransportCandidatesGeneratedConnection;
+	protected SignalConnection remoteTransportCandidateSelectFinishedConnection;
+	protected SignalConnection proxyActivatedConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public JingleFileTransfer(
+			JingleSession session, 
+			final JID target,
+			FileTransferTransporterFactory transporterFactory) {
+		this.session = session;
+		this.target = target;
+		this.transporterFactory = transporterFactory;
+		this.transporter = null;
+		this.ourCandidateSelectFinished = false;
+		this.theirCandidateSelectFinished = false;
+		session.addListener(this);
+	}
+
+	public void handleTransportInfoReceived(final JingleContentID contentID, JingleTransportPayload transport) {
+		logger_.fine("\n");
+		if(transport instanceof JingleS5BTransportPayload) {
+			JingleS5BTransportPayload s5bPayload = (JingleS5BTransportPayload)transport;
+			if (s5bPayload.hasCandidateError() || !s5bPayload.getCandidateUsed().isEmpty()) {
+				logger_.fine("Received candidate decision from peer\n");
+				if (!isTryingCandidates()) {logger_.warning("Incorrect state\n"); return; }
+
+				theirCandidateSelectFinished = true;
+				if (!s5bPayload.hasCandidateError()) {
+					if(!(localCandidates.containsKey(s5bPayload.getCandidateUsed()))) {
+						logger_.warning("Got invalid candidate\n");
+						terminate(JinglePayload.Reason.Type.GeneralError);
+						return;
+					}
+					theirCandidateChoice = localCandidates.get(s5bPayload.getCandidateUsed());
+				}
+				decideOnCandidates();
+			} 
+			else if (!s5bPayload.getActivated().isEmpty()) {
+				logger_.fine("Received peer activate from peer\n");
+				if (!isWaitingForPeerProxyActivate()) { logger_.warning("Incorrect state\n"); return; }
+
+				if (ourCandidateChoice.cid.equals(s5bPayload.getActivated())) {
+					startTransferring(createRemoteCandidateSession());
+				} 
+				else {
+					logger_.warning("ourCandidateChoice doesn't match activated proxy candidate!\n");
+					terminate(JinglePayload.Reason.Type.GeneralError);
+				}
+			}
+			else if (s5bPayload.hasProxyError()) {
+				logger_.fine("Received proxy error. Trying to fall back to IBB.\n");
+				fallback();
+			}
+			else {
+				logger_.fine("Ignoring unknown info\n");
+			}
+		}
+		else {
+			logger_.fine("Ignoring unknown info\n");
+		}
+	}
+
+	protected abstract void handleLocalTransportCandidatesGenerated(
+			final String s5bSessionID, 
+			final Vector<JingleS5BTransportPayload.Candidate> candidates,
+			final String dstAddr);
+
+	protected void handleProxyActivateFinished(final String s5bSessionID, ErrorPayload error) {
+		logger_.fine("\n");
+		if (!isWaitingForLocalProxyActivate()) { logger_.warning("Incorrect state\n"); return; }
+
+		if (error != null) {
+			logger_.fine("Error activating proxy\n");
+			JingleS5BTransportPayload proxyError = new JingleS5BTransportPayload();
+			proxyError.setSessionID(s5bSessionID);
+			proxyError.setProxyError(true);
+			session.sendTransportInfo(getContentID(), proxyError);
+			fallback();
+		} 
+		else {
+			JingleS5BTransportPayload proxyActivate = new JingleS5BTransportPayload();
+			proxyActivate.setSessionID(s5bSessionID);
+			proxyActivate.setActivated(theirCandidateChoice.cid);
+			session.sendTransportInfo(getContentID(), proxyActivate);
+			startTransferring(createLocalCandidateSession());
+		}
+	}
+
+	protected void decideOnCandidates() {
+		logger_.fine("\n");
+		if (!ourCandidateSelectFinished || !theirCandidateSelectFinished) {
+			logger_.fine("Can't make a decision yet!\n");
+			return;
+		}
+		if (ourCandidateChoice == null && theirCandidateChoice == null) {
+			logger_.fine("No candidates succeeded.\n");
+			fallback();
+		}
+		else if (ourCandidateChoice != null && theirCandidateChoice == null) {
+			logger_.fine("Start transfer using remote candidate: " + ourCandidateChoice.cid + ".\n");
+			startTransferViaRemoteCandidate();
+		}
+		else if (theirCandidateChoice != null && ourCandidateChoice == null) {
+			logger_.fine("Start transfer using local candidate: " + theirCandidateChoice.cid + ".\n");
+			startTransferViaLocalCandidate();
+		}
+		else {
+			logger_.fine("Choosing between candidates " 
+				+ ourCandidateChoice.cid + "(" + ourCandidateChoice.priority + ")" + " and " 
+				+ theirCandidateChoice.cid + "(" + theirCandidateChoice.priority + ")\n");
+			if (ourCandidateChoice.priority > theirCandidateChoice.priority) {
+				logger_.fine("Start transfer using remote candidate: " + ourCandidateChoice.cid + ".\n");
+				startTransferViaRemoteCandidate();
+			}
+			else if (ourCandidateChoice.priority < theirCandidateChoice.priority) {
+				logger_.fine("Start transfer using local candidate:" + theirCandidateChoice.cid + ".\n");
+				startTransferViaLocalCandidate();
+			}
+			else {
+				if (hasPriorityOnCandidateTie()) {
+					logger_.fine("Start transfer using remote candidate: " + ourCandidateChoice.cid + "\n");
+					startTransferViaRemoteCandidate();
+				}
+				else {
+					logger_.fine("Start transfer using local candidate: " + theirCandidateChoice.cid + "\n");
+					startTransferViaLocalCandidate();
+				}
+			}
+		}
+	}
+
+	protected void handleRemoteTransportCandidateSelectFinished(final String s5bSessionID, final JingleS5BTransportPayload.Candidate candidate) {
+		logger_.fine("\n");
+
+		ourCandidateChoice = candidate;
+		ourCandidateSelectFinished = true;
+
+		JingleS5BTransportPayload s5bPayload = new JingleS5BTransportPayload();
+		s5bPayload.setSessionID(s5bSessionID);
+		if (candidate != null) {
+			s5bPayload.setCandidateUsed(candidate.cid);
+		}
+		else {
+			s5bPayload.setCandidateError(true);
+		}
+		candidateSelectRequestID = session.sendTransportInfo(getContentID(), s5bPayload);
+
+		decideOnCandidates();
+	}
+
+	protected abstract JingleContentID getContentID();
+	protected abstract void startTransferring(TransportSession session);
+	protected abstract void terminate(JinglePayload.Reason.Type reason);
+	protected abstract void fallback();
+	protected abstract boolean hasPriorityOnCandidateTie();
+	protected abstract boolean isWaitingForPeerProxyActivate();
+	protected abstract boolean isWaitingForLocalProxyActivate();
+	protected abstract boolean isTryingCandidates();
+	protected abstract TransportSession createLocalCandidateSession();
+	protected abstract TransportSession createRemoteCandidateSession();
+	protected abstract void startTransferViaLocalCandidate();
+	protected abstract void startTransferViaRemoteCandidate();
+
+
+	protected void setTransporter(FileTransferTransporter transporter) {
+		//SWIFT_LOG_ASSERT(!this.transporter, error);
+		this.transporter = transporter;
+		localTransportCandidatesGeneratedConnection = transporter.onLocalCandidatesGenerated.connect(new Slot3<String, Vector<JingleS5BTransportPayload.Candidate>, String>() {
+			@Override
+			public void call(String s, Vector<JingleS5BTransportPayload.Candidate> v, String t) {
+				handleLocalTransportCandidatesGenerated(s, v, t);
+			}
+		});
+		remoteTransportCandidateSelectFinishedConnection = transporter.onRemoteCandidateSelectFinished.connect(new Slot2<String, JingleS5BTransportPayload.Candidate>() {
+			@Override
+			public void call(String s, JingleS5BTransportPayload.Candidate c) {
+				handleRemoteTransportCandidateSelectFinished(s, c);
+			}
+		});
+		proxyActivatedConnection = transporter.onProxyActivated.connect(new Slot2<String, ErrorPayload>() {
+			@Override
+			public void call(String s, ErrorPayload e) {
+				handleProxyActivateFinished(s, e);
+			}
+		});
+	}
+
+	protected void removeTransporter() {
+		if (transporter != null) {
+			localTransportCandidatesGeneratedConnection.disconnect();
+			remoteTransportCandidateSelectFinishedConnection.disconnect();
+			proxyActivatedConnection.disconnect();
+			transporter = null;
+		}
+	}
+
+	protected void fillCandidateMap(Map<String, JingleS5BTransportPayload.Candidate> map, final Vector<JingleS5BTransportPayload.Candidate> candidates) {
+		map.clear();
+		for (JingleS5BTransportPayload.Candidate candidate : candidates) {
+			map.put(candidate.cid, candidate);
+		}
+	}
+
+	/*
+	std.string JingleFileTransfer.getS5BDstAddr(const JID& requester, const JID& target) const {
+		return Hexify.hexify(crypto.getSHA1Hash(
+					createSafeByteArray(s5bSessionID + requester.toString() + target.toString())));
+	}
+	*/
+
+	protected JID getInitiator() {
+		return session.getInitiator();
+	}
+
+	protected JID getResponder() {
+		return target;
+	}
+
+	protected static FileTransfer.State.Type getExternalFinishedState(JinglePayload.Reason.Type reason) {
+		if (reason.equals(JinglePayload.Reason.Type.Cancel) || reason.equals(JinglePayload.Reason.Type.Decline)) {
+			return FileTransfer.State.Type.Canceled;
+		}
+		else if (reason.equals(JinglePayload.Reason.Type.Success)) {
+			return FileTransfer.State.Type.Finished;
+		}
+		else {
+			return FileTransfer.State.Type.Failed;
+		}
+	}
+
+	protected static FileTransferError getFileTransferError(JinglePayload.Reason.Type reason) {
+		if (reason.equals(JinglePayload.Reason.Type.Success)) {
+			return null;
+		}
+		else {
+			return new FileTransferError(FileTransferError.Type.UnknownError);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/LocalJingleTransportCandidateGenerator.java b/src/com/isode/stroke/filetransfer/LocalJingleTransportCandidateGenerator.java
new file mode 100644
index 0000000..1cacda7
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/LocalJingleTransportCandidateGenerator.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot;
+import com.isode.stroke.signals.Signal1;
+import java.util.Vector;
+import java.util.logging.Logger;
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.network.HostAddress;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.elements.S5BProxyRequest;
+
+public class LocalJingleTransportCandidateGenerator {
+
+	public static final int LOCAL_PREFERENCE = 0;
+	private SOCKS5BytestreamServerManager s5bServerManager;
+	private SOCKS5BytestreamProxiesManager s5bProxy;
+	private JID ownJID;
+	private IDGenerator idGenerator;
+	//private SOCKS5BytestreamServerInitializeRequest s5bServerInitializeRequest;
+	private SOCKS5BytestreamServerResourceUser s5bServerResourceUser_;
+	private SOCKS5BytestreamServerPortForwardingUser s5bServerPortForwardingUser_;
+	private boolean triedServerInit_;
+	private boolean triedForwarding_;
+	private boolean triedProxyDiscovery_;
+	private FileTransferOptions options_;
+	private SignalConnection onDiscoveredProxiesChangedConnection;
+	private Logger logger_  = Logger.getLogger(this.getClass().getName());
+
+	public LocalJingleTransportCandidateGenerator(
+			SOCKS5BytestreamServerManager s5bServerManager,
+			SOCKS5BytestreamProxiesManager s5bProxy, 
+			final JID ownJID,
+			IDGenerator idGenerator,
+			final FileTransferOptions options) {
+		this.s5bServerManager = s5bServerManager;
+		this.s5bProxy = s5bProxy;
+		this.ownJID = ownJID;
+		this.idGenerator = idGenerator;
+		triedProxyDiscovery_ = false;
+		triedServerInit_ = false;
+		triedForwarding_ = false;
+		this.options_ = options;
+	}
+
+	public void start() {
+		//assert(s5bServerInitializeRequest == null);
+		if (options_.isDirectAllowed() || options_.isAssistedAllowed()) {
+			s5bServerResourceUser_ = s5bServerManager.aquireResourceUser();
+			if (s5bServerResourceUser_.isInitialized()) {
+				handleS5BServerInitialized(true);
+			}
+			else {
+				s5bServerResourceUser_.onSuccessfulInitialized.connect(new Slot1<Boolean>() {
+					@Override
+					public void call(Boolean b) {
+						handleS5BServerInitialized(b);
+					}
+				});
+			}
+		} else {
+			handleS5BServerInitialized(false);
+		}
+
+		if (options_.isProxiedAllowed()) {
+			onDiscoveredProxiesChangedConnection = s5bProxy.onDiscoveredProxiesChanged.connect(new Slot() {
+				@Override
+				public void call() {
+					handleDiscoveredProxiesChanged();
+				}
+			});
+			if (s5bProxy.getOrDiscoverS5BProxies() != null) {
+				handleDiscoveredProxiesChanged();
+			}
+		}
+	}
+
+	public void stop() {
+		onDiscoveredProxiesChangedConnection.disconnect();
+		if (s5bServerPortForwardingUser_ != null) {
+			s5bServerPortForwardingUser_.onSetup.disconnectAll();
+			s5bServerPortForwardingUser_ = null;
+		}
+		if (s5bServerResourceUser_ != null) {
+			s5bServerResourceUser_.onSuccessfulInitialized.disconnectAll();
+			s5bServerResourceUser_ = null;
+		}
+	}
+
+	public Signal1<Vector<JingleS5BTransportPayload.Candidate>> onLocalTransportCandidatesGenerated = new Signal1<Vector<JingleS5BTransportPayload.Candidate>>();
+
+	private void handleS5BServerInitialized(boolean success) {
+		if (s5bServerResourceUser_ != null) {
+			s5bServerResourceUser_.onSuccessfulInitialized.disconnectAll();
+		}
+		triedServerInit_ = true;
+		if (success) {
+			if (options_.isAssistedAllowed()) {
+				// try to setup port forwarding
+				s5bServerPortForwardingUser_ = s5bServerManager.aquirePortForwardingUser();
+				s5bServerPortForwardingUser_.onSetup.connect(new Slot1<Boolean>() {
+					@Override
+					public void call(Boolean b) {
+						handlePortForwardingSetup(b);
+					}
+				});
+				if (s5bServerPortForwardingUser_.isForwardingSetup()) {
+					handlePortForwardingSetup(true);
+				}
+			}
+		}
+		else {
+			logger_.warning("Unable to start SOCKS5 server\n");
+			if (s5bServerResourceUser_ != null) {
+				s5bServerResourceUser_.onSuccessfulInitialized.disconnectAll();
+			}
+			s5bServerResourceUser_ = null;
+			handlePortForwardingSetup(false);
+		}
+		checkS5BCandidatesReady();
+	}
+
+	private void handlePortForwardingSetup(boolean success) {
+		if (s5bServerPortForwardingUser_ != null) {
+			s5bServerPortForwardingUser_.onSetup.disconnectAll();
+		}
+		triedForwarding_ = true;
+		checkS5BCandidatesReady();
+	}
+
+	private void handleDiscoveredProxiesChanged() {
+		if (s5bProxy != null) {
+			s5bProxy.onDiscoveredProxiesChanged.disconnectAll();
+		}
+		triedProxyDiscovery_ = true;
+		checkS5BCandidatesReady();
+	}
+
+	private void checkS5BCandidatesReady() {
+		if ((!options_.isDirectAllowed()  || (options_.isDirectAllowed()  && triedServerInit_)) &&
+			(!options_.isProxiedAllowed() || (options_.isProxiedAllowed() && triedProxyDiscovery_)) &&
+			(!options_.isAssistedAllowed()  || (options_.isAssistedAllowed()  && triedForwarding_))) {
+			emitOnLocalTransportCandidatesGenerated();
+		}
+	}
+
+	private void emitOnLocalTransportCandidatesGenerated() {
+		Vector<JingleS5BTransportPayload.Candidate> candidates = new Vector<JingleS5BTransportPayload.Candidate>();
+
+		if (options_.isDirectAllowed()) {
+			// get direct candidates
+			Vector<HostAddressPort> directCandidates = s5bServerManager.getHostAddressPorts();
+			for(HostAddressPort addressPort : directCandidates) {
+				JingleS5BTransportPayload.Candidate candidate = new JingleS5BTransportPayload.Candidate();
+				candidate.type = JingleS5BTransportPayload.Candidate.Type.DirectType;
+				candidate.jid = ownJID;
+				candidate.hostPort = addressPort;
+				candidate.priority = 65536 * 126 + LOCAL_PREFERENCE;
+				candidate.cid = idGenerator.generateID();
+				candidates.add(candidate);
+			}
+		}
+
+		if (options_.isAssistedAllowed()) {
+			// get assissted candidates
+			Vector<HostAddressPort> assisstedCandidates = s5bServerManager.getAssistedHostAddressPorts();
+			for(HostAddressPort addressPort : assisstedCandidates) {
+				JingleS5BTransportPayload.Candidate candidate = new JingleS5BTransportPayload.Candidate();
+				candidate.type = JingleS5BTransportPayload.Candidate.Type.AssistedType;
+				candidate.jid = ownJID;
+				candidate.hostPort = addressPort;
+				candidate.priority = 65536 * 120 + LOCAL_PREFERENCE;
+				candidate.cid = idGenerator.generateID();
+				candidates.add(candidate);
+			}
+		}
+
+		if (options_.isProxiedAllowed() && s5bProxy.getOrDiscoverS5BProxies() != null) {
+			for(S5BProxyRequest proxy : s5bProxy.getOrDiscoverS5BProxies()) {
+				if (proxy.getStreamHost() != null) { // FIXME: Added this test, because there were cases where this wasn't initialized. Investigate this. (Remko)
+					JingleS5BTransportPayload.Candidate candidate = new JingleS5BTransportPayload.Candidate();
+					candidate.type = JingleS5BTransportPayload.Candidate.Type.ProxyType;
+					candidate.jid = (proxy.getStreamHost()).jid;
+					HostAddress address = new HostAddress((proxy.getStreamHost()).host);
+					assert(address.isValid());
+					candidate.hostPort = new HostAddressPort(address, (proxy.getStreamHost()).port);
+					candidate.priority = 65536 * 10 + LOCAL_PREFERENCE;
+					candidate.cid = idGenerator.generateID();
+					candidates.add(candidate);
+				}
+			}
+		}
+
+		onLocalTransportCandidatesGenerated.emit(candidates);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/OutgoingFileTransfer.java b/src/com/isode/stroke/filetransfer/OutgoingFileTransfer.java
new file mode 100644
index 0000000..52aa378
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/OutgoingFileTransfer.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+
+/**
+ * Because of the lack of multiple inheritance in Java, this has to be done
+ * slightly differently from Swiften. What happens is that the methods in Swiften
+ * are provided abstract here. Any class implementing this interface directly/indirectly (through other interface) has to implement these methods.
+ * OutgoingJingleFileTransfer and OutgoingSIFileTransfer implements this interface and will also need to implement methods from FileTransfer (which is an interface).
+ */
+public interface OutgoingFileTransfer extends FileTransfer {
+
+	public void start();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/OutgoingFileTransferManager.java b/src/com/isode/stroke/filetransfer/OutgoingFileTransferManager.java
new file mode 100644
index 0000000..ce848ee
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/OutgoingFileTransferManager.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.jingle.IncomingJingleSessionHandler;
+import com.isode.stroke.jingle.JingleSessionManager;
+import com.isode.stroke.jingle.JingleSession;
+import com.isode.stroke.elements.JinglePayload;
+import com.isode.stroke.elements.JingleContentPayload;
+import com.isode.stroke.elements.JingleFileTransferDescription;
+import com.isode.stroke.elements.JingleFileTransferFileInfo;
+import com.isode.stroke.jingle.JingleSessionImpl;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.jingle.Jingle;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.base.IDGenerator;
+
+public class OutgoingFileTransferManager {
+
+	private JingleSessionManager jingleSessionManager;
+	private IQRouter iqRouter;
+	private FileTransferTransporterFactory transporterFactory;
+	private TimerFactory timerFactory;
+	private IDGenerator idGenerator;
+	private CryptoProvider crypto;
+
+	public OutgoingFileTransferManager(
+			JingleSessionManager jingleSessionManager, 
+			IQRouter router, 
+			FileTransferTransporterFactory transporterFactory,
+			TimerFactory timerFactory,
+			CryptoProvider crypto) {
+		this.jingleSessionManager = jingleSessionManager;
+		this.iqRouter = router;
+		this.transporterFactory = transporterFactory;
+		this.timerFactory = timerFactory;
+		this.idGenerator = idGenerator;
+		this.crypto = crypto;
+		idGenerator = new IDGenerator();
+	}
+
+	public OutgoingFileTransfer createOutgoingFileTransfer(
+			final JID from, 
+			final JID recipient, 
+			ReadBytestream readBytestream, 
+			final JingleFileTransferFileInfo fileInfo,
+			final FileTransferOptions config) {
+		JingleSessionImpl jingleSession = new JingleSessionImpl(from, recipient, idGenerator.generateID(), iqRouter);
+		jingleSessionManager.registerOutgoingSession(from, jingleSession);
+		return new OutgoingJingleFileTransfer(
+					recipient, 
+					jingleSession, 
+					readBytestream, 
+					transporterFactory,
+					timerFactory,
+					idGenerator, 
+					fileInfo, 
+					config,
+					crypto);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/OutgoingJingleFileTransfer.java b/src/com/isode/stroke/filetransfer/OutgoingJingleFileTransfer.java
new file mode 100644
index 0000000..10760a1
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/OutgoingJingleFileTransfer.java
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.jingle.JingleSession;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.network.Timer;
+import com.isode.stroke.crypto.CryptoProvider;
+import com.isode.stroke.base.IDGenerator;
+import com.isode.stroke.base. ByteArray;
+import com.isode.stroke.elements.JingleFileTransferFileInfo;
+import com.isode.stroke.elements.JingleDescription;
+import com.isode.stroke.elements.JingleTransportPayload;
+import com.isode.stroke.elements.JingleIBBTransportPayload;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import com.isode.stroke.elements.JinglePayload;
+import com.isode.stroke.elements.JingleContentPayload;
+import com.isode.stroke.elements.JingleFileTransferDescription;
+import com.isode.stroke.elements.HashElement;
+import com.isode.stroke.elements.JingleFileTransferHash;
+import com.isode.stroke.jingle.JingleContentID;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot;
+import java.util.logging.Logger;
+import java.util.Vector;
+
+public class OutgoingJingleFileTransfer extends JingleFileTransfer implements OutgoingFileTransfer {
+
+	private long fileSizeInBytes = 0; //FileTransferVariables
+	private String filename = ""; //FileTransferVariables
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public String getFileName() {
+		return filename;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public long getFileSizeInBytes() {
+		return fileSizeInBytes;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public void setFileInfo(final String name, long size) {
+		this.filename = name;
+		this.fileSizeInBytes = size;
+	}
+
+	public static final int DEFAULT_BLOCK_SIZE = 4096;
+	private IDGenerator idGenerator;
+	private ReadBytestream stream;
+	private JingleFileTransferFileInfo fileInfo;
+	private FileTransferOptions options;
+	private JingleContentID contentID;
+	private IncrementalBytestreamHashCalculator hashCalculator;
+	private State state;
+	private boolean candidateAcknowledged;
+
+	private Timer waitForRemoteTermination;
+
+	private SignalConnection processedBytesConnection;
+	private SignalConnection transferFinishedConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public OutgoingJingleFileTransfer(
+		final JID toJID,
+		JingleSession session,
+		ReadBytestream stream,
+		FileTransferTransporterFactory transporterFactory,
+		TimerFactory timerFactory,
+		IDGenerator idGenerator,
+		final JingleFileTransferFileInfo fileInfo,
+		final FileTransferOptions options,
+		CryptoProvider crypto) {
+		super(session, toJID, transporterFactory);
+		this.idGenerator = idGenerator;
+		this.stream = stream;
+		this.fileInfo = fileInfo;
+		this.session = session;
+		this.contentID = new JingleContentID(idGenerator.generateID(), JingleContentPayload.Creator.InitiatorCreator);
+		this.state = State.Initial;
+		this.candidateAcknowledged = false;
+		setFileInfo(fileInfo.getName(), fileInfo.getSize());
+
+		// calculate both, MD5 and SHA-1 since we don't know which one the other side supports
+		hashCalculator = new IncrementalBytestreamHashCalculator(true, true, crypto);
+		stream.onRead.connect(new Slot1<ByteArray>() {
+			@Override
+			public void call(ByteArray b) {
+				hashCalculator.feedData(b);
+			}
+		});
+		waitForRemoteTermination = timerFactory.createTimer(5000);
+		waitForRemoteTermination.onTick.connect(new Slot() {
+			@Override
+			public void call() {
+				handleWaitForRemoteTerminationTimeout();
+			}
+		});
+	}
+
+	/**
+	* OutgoingFileTransferMethod.
+	*/
+	@Override
+	public void start() {
+		logger_.fine("\n");
+		if (!State.Initial.equals(state)) {
+			logger_.warning("Incorrect state\n");
+			return;
+		}
+
+		setTransporter(transporterFactory.createInitiatorTransporter(getInitiator(), getResponder(), options));
+		setState(State.GeneratingInitialLocalCandidates);
+		transporter.startGeneratingLocalCandidates();
+	}
+
+	/**
+	* JingleFileTransferMethod.
+	*/
+	@Override
+	public void cancel() {
+		terminate(JinglePayload.Reason.Type.Cancel);
+	}
+
+	private enum State {
+		Initial,
+		GeneratingInitialLocalCandidates,
+		WaitingForAccept,
+		TryingCandidates,
+		WaitingForPeerProxyActivate,
+		WaitingForLocalProxyActivate,
+		WaitingForCandidateAcknowledge,
+		FallbackRequested,
+		Transferring,
+		WaitForTermination,
+		Finished
+	};
+
+	public void handleSessionAcceptReceived(final JingleContentID contentID, JingleDescription description, JingleTransportPayload transportPayload) {
+		logger_.fine("\n");
+		if (!State.WaitingForAccept.equals(state)) { logger_.warning("Incorrect state\n"); return; }
+
+		if (transportPayload instanceof JingleS5BTransportPayload) {
+			JingleS5BTransportPayload s5bPayload = (JingleS5BTransportPayload)transportPayload;
+			transporter.addRemoteCandidates(s5bPayload.getCandidates(), s5bPayload.getDstAddr());
+			setState(State.TryingCandidates);
+			transporter.startTryingRemoteCandidates();
+		}
+		else {
+			logger_.fine("Unknown transport payload. Falling back.\n");
+			fallback();
+		}
+	}
+
+	public void handleSessionTerminateReceived(JinglePayload.Reason reason) {
+		logger_.fine("\n");
+		if (State.Finished.equals(state)) { logger_.warning("Incorrect state: " + state + "\n"); return; }
+
+		stopAll();
+		if (State.WaitForTermination.equals(state)) {
+			waitForRemoteTermination.stop();
+		}
+		if (reason != null && JinglePayload.Reason.Type.Cancel.equals(reason.type)) {
+			setFinishedState(FileTransfer.State.Type.Canceled, new FileTransferError(FileTransferError.Type.PeerError));
+		}
+		else if (reason != null && JinglePayload.Reason.Type.Decline.equals(reason.type)) {
+			setFinishedState(FileTransfer.State.Type.Canceled, null);
+		}
+		else if (reason != null && JinglePayload.Reason.Type.Success.equals(reason.type)) {
+			setFinishedState(FileTransfer.State.Type.Finished, null);
+		}
+		else {
+			setFinishedState(FileTransfer.State.Type.Failed, new FileTransferError(FileTransferError.Type.PeerError));
+		}
+	}
+
+	public void handleTransportAcceptReceived(final JingleContentID contentID, JingleTransportPayload transport) {
+		logger_.fine("\n");
+		if (!State.FallbackRequested.equals(state)) { logger_.warning("Incorrect state\n"); return; }
+
+		if (transport instanceof JingleIBBTransportPayload) {
+			JingleIBBTransportPayload ibbPayload = (JingleIBBTransportPayload)transport;
+			startTransferring(transporter.createIBBSendSession(ibbPayload.getSessionID(), ( ibbPayload.getBlockSize() != null ? ibbPayload.getBlockSize() : DEFAULT_BLOCK_SIZE), stream));
+		} 
+		else {
+			logger_.fine("Unknown transport replacement\n");
+			terminate(JinglePayload.Reason.Type.FailedTransport);
+		}
+	}
+
+	public void handleTransportRejectReceived(final JingleContentID contentID, JingleTransportPayload transport) {
+		logger_.fine("\n");
+
+		terminate(JinglePayload.Reason.Type.UnsupportedTransports);
+	}
+
+	protected void startTransferViaRemoteCandidate() {
+		logger_.fine("\n");
+
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(ourCandidateChoice.type)) {
+			setState(State.WaitingForPeerProxyActivate);
+		} 
+		else {
+			transportSession = createRemoteCandidateSession();
+			startTransferringIfCandidateAcknowledged();
+		}
+	}
+
+	protected void startTransferViaLocalCandidate() {
+		logger_.fine("\n");
+
+		if (JingleS5BTransportPayload.Candidate.Type.ProxyType.equals(theirCandidateChoice.type)) {
+			setState(State.WaitingForLocalProxyActivate);
+			transporter.startActivatingProxy(theirCandidateChoice.jid);
+		} 
+		else {
+			transportSession = createLocalCandidateSession();
+			startTransferringIfCandidateAcknowledged();
+		}
+	}
+
+	private void startTransferringIfCandidateAcknowledged() {
+		if (candidateAcknowledged) {
+			startTransferring(transportSession);
+		}
+		else {
+			setState(State.WaitingForCandidateAcknowledge);
+		}
+	}
+
+	protected void handleLocalTransportCandidatesGenerated(final String s5bSessionID, final Vector<JingleS5BTransportPayload.Candidate> candidates, final String dstAddr) {
+		logger_.fine("\n");
+		if (!State.GeneratingInitialLocalCandidates.equals(state)) { logger_.warning("Incorrect state\n"); return; }
+
+		fillCandidateMap(localCandidates, candidates);
+
+		JingleFileTransferDescription description = new JingleFileTransferDescription();
+		fileInfo.addHash(new HashElement("sha-1", new ByteArray()));
+		fileInfo.addHash(new HashElement("md5", new ByteArray()));
+		description.setFileInfo(fileInfo);
+
+		JingleS5BTransportPayload transport = new JingleS5BTransportPayload();
+		transport.setSessionID(s5bSessionID);
+		transport.setMode(JingleS5BTransportPayload.Mode.TCPMode);
+		transport.setDstAddr(dstAddr);
+		for(JingleS5BTransportPayload.Candidate candidate : candidates) {
+			transport.addCandidate(candidate);
+			logger_.fine("\t" + "S5B candidate: " + candidate.hostPort.toString() + "\n");
+		}
+		setState(State.WaitingForAccept);
+		session.sendInitiate(contentID, description, transport);
+	}
+
+	public void handleTransportInfoAcknowledged(final String id) {
+		if (id.equals(candidateSelectRequestID)) {
+			candidateAcknowledged = true;
+		}
+		if (State.WaitingForCandidateAcknowledge.equals(state)) {
+			startTransferring(transportSession);
+		}
+	}
+
+	protected JingleContentID getContentID() {
+		return contentID;
+	}
+
+	protected void terminate(JinglePayload.Reason.Type reason) {
+		logger_.fine(reason + "\n");
+
+		if (!State.Initial.equals(state) && !State.GeneratingInitialLocalCandidates.equals(state) && !State.Finished.equals(state)) {
+			session.sendTerminate(reason);
+		}
+		stopAll();
+		setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));
+	}
+
+	protected void fallback() {
+		if (options.isInBandAllowed()) {
+			logger_.fine("Trying to fallback to IBB transport.\n");
+			JingleIBBTransportPayload ibbTransport = new JingleIBBTransportPayload();
+			ibbTransport.setBlockSize(DEFAULT_BLOCK_SIZE);
+			ibbTransport.setSessionID(idGenerator.generateID());
+			setState(State.FallbackRequested);
+			session.sendTransportReplace(contentID, ibbTransport);
+		}
+		else {
+			logger_.fine("Fallback to IBB transport not allowed.\n");
+			terminate(JinglePayload.Reason.Type.ConnectivityError);
+		}
+	}
+
+	private void handleTransferFinished(FileTransferError error) {
+		logger_.fine("\n");
+		if (!State.Transferring.equals(state)) { logger_.warning("Incorrect state: " + state + "\n"); return; }
+
+		if (error != null) {
+			terminate(JinglePayload.Reason.Type.ConnectivityError);
+		} 
+		else {
+			sendSessionInfoHash();
+
+			// wait for other party to terminate session after they have verified the hash
+			setState(State.WaitForTermination);
+			waitForRemoteTermination.start();
+		}
+	}
+
+	private void sendSessionInfoHash() {
+		logger_.fine("\n");
+
+		JingleFileTransferHash hashElement = new JingleFileTransferHash();
+		hashElement.getFileInfo().addHash(new HashElement("sha-1", hashCalculator.getSHA1Hash()));
+		hashElement.getFileInfo().addHash(new HashElement("md5", hashCalculator.getMD5Hash()));
+		session.sendInfo(hashElement);
+	}
+
+	protected void startTransferring(TransportSession transportSession) {
+		logger_.fine("\n");
+
+		this.transportSession = transportSession;
+		processedBytesConnection = transportSession.onBytesSent.connect(onProcessedBytes);
+		transferFinishedConnection = transportSession.onFinished.connect(new Slot1<FileTransferError>() {
+			@Override
+			public void call(FileTransferError e) {
+				handleTransferFinished(e);
+			}
+		});
+		setState(State.Transferring);
+		transportSession.start();
+	}
+
+	protected boolean hasPriorityOnCandidateTie() {
+		return true;
+	}
+
+	protected boolean isWaitingForPeerProxyActivate() {
+		return State.WaitingForPeerProxyActivate.equals(state);
+	}
+
+	protected boolean isWaitingForLocalProxyActivate() {
+		return State.WaitingForLocalProxyActivate.equals(state);
+	}
+
+	protected boolean isTryingCandidates() {
+		return State.TryingCandidates.equals(state);
+	}
+
+	protected TransportSession createLocalCandidateSession() {
+		return transporter.createLocalCandidateSession(stream, theirCandidateChoice);
+	}
+
+	protected TransportSession createRemoteCandidateSession() {
+		return transporter.createRemoteCandidateSession(stream, ourCandidateChoice);
+	}
+
+	private void handleWaitForRemoteTerminationTimeout() {
+		assert(state.equals(State.WaitForTermination));
+		logger_.warning("Other party did not terminate session. Terminate it now.\n");
+		waitForRemoteTermination.stop();
+		terminate(JinglePayload.Reason.Type.MediaError);
+	}
+
+	private void stopAll() {
+		logger_.fine(state + "\n");
+		switch (state) {
+			case Initial: logger_.warning("Not yet started\n"); break;
+			case GeneratingInitialLocalCandidates: transporter.stopGeneratingLocalCandidates(); break;
+			case WaitingForAccept: break;
+			case TryingCandidates: transporter.stopTryingRemoteCandidates(); break;
+			case FallbackRequested: break;
+			case WaitingForPeerProxyActivate: break;
+			case WaitingForLocalProxyActivate: transporter.stopActivatingProxy(); break;
+			case WaitingForCandidateAcknowledge: // Fallthrough
+			case Transferring:
+				assert(transportSession != null);
+				processedBytesConnection.disconnect();
+				transferFinishedConnection.disconnect();
+				transportSession.stop();
+				transportSession = null;
+				break;
+			case WaitForTermination:
+				break;
+			case Finished: logger_.warning("Already finished\n"); break;
+		}
+		if (!State.Initial.equals(state)) {
+			removeTransporter();
+		}
+	}
+
+	private void setState(State state) {
+		logger_.fine(state + "\n");
+		this.state = state;
+		onStateChanged.emit(new FileTransfer.State(getExternalState(state)));
+	}
+
+	private void setFinishedState(FileTransfer.State.Type type, final FileTransferError error) {
+		logger_.fine("\n");
+		this.state = State.Finished;
+		onStateChanged.emit(new FileTransfer.State(type));
+		onFinished.emit(error);
+	}
+
+	private static FileTransfer.State.Type getExternalState(State state) {
+		switch (state) {
+			case Initial: return FileTransfer.State.Type.Initial;
+			case GeneratingInitialLocalCandidates: return FileTransfer.State.Type.WaitingForStart;
+			case WaitingForAccept: return FileTransfer.State.Type.WaitingForAccept;
+			case TryingCandidates: return FileTransfer.State.Type.Negotiating;
+			case WaitingForPeerProxyActivate: return FileTransfer.State.Type.Negotiating;
+			case WaitingForLocalProxyActivate: return FileTransfer.State.Type.Negotiating;
+			case WaitingForCandidateAcknowledge: return FileTransfer.State.Type.Negotiating;
+			case FallbackRequested: return FileTransfer.State.Type.Negotiating;
+			case Transferring: return FileTransfer.State.Type.Transferring;
+			case WaitForTermination: return FileTransfer.State.Type.Transferring;
+			case Finished: return FileTransfer.State.Type.Finished;
+		}
+		assert(false);
+		return FileTransfer.State.Type.Initial;
+	}
+
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/OutgoingSIFileTransfer.java b/src/com/isode/stroke/filetransfer/OutgoingSIFileTransfer.java
new file mode 100644
index 0000000..4ba17de
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/OutgoingSIFileTransfer.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.elements.StreamInitiation;
+import com.isode.stroke.elements.Bytestreams;
+
+public class OutgoingSIFileTransfer implements OutgoingFileTransfer {
+
+	private long fileSizeInBytes = 0; //FileTransferVariables
+	private String filename = ""; //FileTransferVariables
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public String getFileName() {
+		return filename;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public long getFileSizeInBytes() {
+		return fileSizeInBytes;
+	}
+
+	/**
+	* FileTransferMethod.
+	*/
+	@Override
+	public void setFileInfo(final String name, long size) {
+		this.filename = name;
+		this.fileSizeInBytes = size;
+	}
+
+	private String id = "";
+	private JID from;
+	private JID to;
+	private String name = "";
+	private long size;
+	private String description = "";
+	private ReadBytestream bytestream;
+	private IQRouter iqRouter;
+	private SOCKS5BytestreamServer socksServer;
+	private IBBSendSession ibbSession;
+
+	public OutgoingSIFileTransfer(final String id, final JID from, final JID to, final String name, long size, final String description, ReadBytestream bytestream, IQRouter iqRouter, SOCKS5BytestreamServer socksServer) {
+		this.id = id;
+		this.from = from;
+		this.to = to;
+		this.name = name;
+		this.size = size;
+		this.description = description;
+		this.bytestream = bytestream;
+		this.iqRouter = iqRouter;
+		this.socksServer = socksServer;
+		this.ibbSession = ibbSession;
+	}
+
+	/**
+	* OutgoingFileTransferMethod.
+	*/
+	@Override
+	public void start() {
+		/*
+		StreamInitiation::ref streamInitiation(new StreamInitiation());
+		streamInitiation.setID(id);
+		streamInitiation.setFileInfo(StreamInitiationFileInfo(name, description, size));
+		//streamInitiation.addProvidedMethod("http://jabber.org/protocol/bytestreams");
+		streamInitiation.addProvidedMethod("http://jabber.org/protocol/ibb");
+		StreamInitiationRequest::ref request = StreamInitiationRequest::create(to, streamInitiation, iqRouter);
+		request.onResponse.connect(boost::bind(&OutgoingSIFileTransfer::handleStreamInitiationRequestResponse, this, _1, _2));
+		request.send();
+		*/
+	}
+
+	public void stop() {
+	}
+
+	public final Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+
+	private void handleStreamInitiationRequestResponse(StreamInitiation stream, ErrorPayload error) {
+		/*
+		if (error) {
+			finish(FileTransferError());
+		}
+		else {
+			if (response->getRequestedMethod() == "http://jabber.org/protocol/bytestreams") {
+				socksServer->addReadBytestream(id, from, to, bytestream);
+				Bytestreams::ref bytestreams(new Bytestreams());
+				bytestreams->setStreamID(id);
+				HostAddressPort addressPort = socksServer->getAddressPort();
+				bytestreams->addStreamHost(Bytestreams::StreamHost(addressPort.getAddress().toString(), from, addressPort.getPort()));
+				BytestreamsRequest::ref request = BytestreamsRequest::create(to, bytestreams, iqRouter);
+				request->onResponse.connect(boost::bind(&OutgoingSIFileTransfer::handleBytestreamsRequestResponse, this, _1, _2));
+				request->send();
+			}
+			else if (response->getRequestedMethod() == "http://jabber.org/protocol/ibb") {
+				ibbSession = boost::make_shared<IBBSendSession>(id, from, to, bytestream, iqRouter);
+				ibbSession->onFinished.connect(boost::bind(&OutgoingSIFileTransfer::handleIBBSessionFinished, this, _1));
+				ibbSession->start();
+			}
+		}
+		*/
+	}
+
+	private void handleBytestreamsRequestResponse(Bytestreams stream, ErrorPayload error) {
+		/*
+		if (error) {
+			finish(FileTransferError());
+		}
+		*/
+		//socksServer->onTransferFinished.connect();
+	}
+
+	private void finish(FileTransferError error) {
+		/*
+		if (ibbSession) {
+			ibbSession->onFinished.disconnect(boost::bind(&OutgoingSIFileTransfer::handleIBBSessionFinished, this, _1));
+			ibbSession.reset();
+		}
+		socksServer->removeReadBytestream(id, from, to);
+		onFinished(error);
+		*/
+	}
+
+	private void handleIBBSessionFinished(FileTransferError error) {
+		//finish(error);
+	}
+
+	public void cancel() {
+		
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/ReadBytestream.java b/src/com/isode/stroke/filetransfer/ReadBytestream.java
new file mode 100644
index 0000000..a247653
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/ReadBytestream.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2010 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.Signal;
+import com.isode.stroke.base.ByteArray;
+
+public abstract class ReadBytestream {
+
+	public final Signal onDataAvailable = new Signal();
+	public final Signal1<ByteArray> onRead = new Signal1<ByteArray>();
+
+	/**
+	 * Return an empty vector if no more data is available.
+	 * Use onDataAvailable signal for signaling there is data available again.
+	 */
+	public abstract ByteArray read(int size);
+
+	public abstract boolean isFinished();
+
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/RemoteJingleTransportCandidateSelector.java b/src/com/isode/stroke/filetransfer/RemoteJingleTransportCandidateSelector.java
new file mode 100644
index 0000000..1d1c822
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/RemoteJingleTransportCandidateSelector.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2013-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import java.util.PriorityQueue;
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.network.Connection;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Signal2;
+import com.isode.stroke.elements.JingleS5BTransportPayload;
+import java.util.logging.Logger;
+import java.util.Vector;
+
+public class RemoteJingleTransportCandidateSelector {
+
+	private ConnectionFactory connectionFactory;
+	private TimerFactory timerFactory;
+
+	private PriorityQueue<JingleS5BTransportPayload.Candidate> candidates = new PriorityQueue<JingleS5BTransportPayload.Candidate>(25, new JingleS5BTransportPayload.CompareCandidate());
+	private SOCKS5BytestreamClientSession s5bSession;
+	private SignalConnection sessionReadyConnection;
+	private JingleS5BTransportPayload.Candidate lastCandidate;
+	private String socks5DstAddr;
+	private FileTransferOptions options;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public RemoteJingleTransportCandidateSelector(ConnectionFactory connectionFactory, TimerFactory timerFactory, final FileTransferOptions options) {
+		this.connectionFactory = connectionFactory;
+		this.timerFactory = timerFactory;
+		this.options = options;
+	}
+
+	public void addCandidates(final Vector<JingleS5BTransportPayload.Candidate> candidates) {
+		for(JingleS5BTransportPayload.Candidate c : candidates) {
+			this.candidates.add(c);
+		}
+	}
+
+	public void setSOCKS5DstAddr(final String socks5DstAddr) {
+		this.socks5DstAddr = socks5DstAddr;
+	}
+
+	public void startSelectingCandidate() {
+		tryNextCandidate();
+	}
+
+	public void stopSelectingCandidate() {
+		if (s5bSession != null) {
+			sessionReadyConnection.disconnect();
+			s5bSession.stop();
+		}
+	}
+
+	public Signal2<JingleS5BTransportPayload.Candidate, SOCKS5BytestreamClientSession> onCandidateSelectFinished = new Signal2<JingleS5BTransportPayload.Candidate, SOCKS5BytestreamClientSession>();
+
+	private void tryNextCandidate() {
+		if (candidates.isEmpty()) {
+			logger_.fine("No more candidates\n");
+			onCandidateSelectFinished.emit(null, null);
+		} 
+		else {
+			lastCandidate = candidates.peek();
+			candidates.poll();
+			logger_.fine("Trying candidate " + lastCandidate.cid + "\n");
+			if ((lastCandidate.type.equals(JingleS5BTransportPayload.Candidate.Type.DirectType) && options.isDirectAllowed()) ||
+				(lastCandidate.type.equals(JingleS5BTransportPayload.Candidate.Type.AssistedType) && options.isAssistedAllowed()) ||
+				(lastCandidate.type.equals(JingleS5BTransportPayload.Candidate.Type.ProxyType) && options.isProxiedAllowed())) {
+				Connection connection = connectionFactory.createConnection();
+				s5bSession = new SOCKS5BytestreamClientSession(connection, lastCandidate.hostPort, socks5DstAddr, timerFactory);
+				sessionReadyConnection = s5bSession.onSessionReady.connect(new Slot1<Boolean>() {
+					@Override
+					public void call(Boolean b) {
+						handleSessionReady(b);
+					}
+				});
+				s5bSession.start();
+			} 
+			else {
+				logger_.fine("Can't handle this type of candidate\n");
+				tryNextCandidate();
+			}
+		}
+	}
+
+	private void handleSessionReady(boolean error) {
+		sessionReadyConnection.disconnect();
+		if (error) {
+			s5bSession = null;
+			tryNextCandidate();
+		}
+		else {
+			onCandidateSelectFinished.emit(lastCandidate, s5bSession);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/S5BTransportSession.java b/src/com/isode/stroke/filetransfer/S5BTransportSession.java
new file mode 100644
index 0000000..768354f
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/S5BTransportSession.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.SignalConnection;
+
+public class S5BTransportSession<T> extends TransportSession {
+
+	public S5BTransportSession(
+		T session,
+		ReadBytestream readStream) {
+			this.session = session;
+			this.readStream = readStream;
+			initialize();
+	}
+
+	public S5BTransportSession(
+		T session,
+		WriteBytestream writeStream) {
+			this.session = session;
+			this.writeStream = writeStream;
+			initialize();
+	}
+
+	public void start() {
+		if (readStream != null) {
+			//session.startSending(readStream);
+		}
+		else {
+			//session.startReceiving(writeStream);
+		}
+	}
+
+	public void stop() {
+		//session.stop();
+	}
+
+	private void initialize() {
+		//finishedConnection = session.onFinished.connect(onFinished);
+		//bytesSentConnection = session.onBytesSent.connect(onBytesSent);
+	}
+
+	private T session;
+	private ReadBytestream readStream;
+	private WriteBytestream writeStream;
+
+	private SignalConnection finishedConnection;
+	private SignalConnection bytesSentConnection;
+}
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamClientSession.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamClientSession.java
new file mode 100644
index 0000000..25aadc4
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamClientSession.java
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.base.ByteArray;
+import com.isode.stroke.base.SafeByteArray;
+import com.isode.stroke.network.Connection;
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.network.Timer;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.Slot;
+import com.isode.stroke.stringcodecs.Hexify;
+import java.util.logging.Logger;
+
+/**
+ * A session which has been connected to a SOCKS5 server (requester).
+ *
+ */
+public class SOCKS5BytestreamClientSession {
+
+	public enum State {
+		Initial(0),
+		Hello(1),
+		Authenticating(2),
+		Ready(3),
+		Writing(4),
+		Reading(5),
+		Finished(6);
+		private State(int x) {
+			description = x;
+		}
+		public int description;
+	};
+
+	private Connection connection;
+	private HostAddressPort addressPort;
+	private String destination; // hexify(SHA1(sessionID + requester + target))
+
+	private State state;
+
+	private ByteArray unprocessedData;
+	private ByteArray authenticateAddress;
+
+	private int chunkSize;
+	private WriteBytestream writeBytestream;
+	private ReadBytestream readBytestream;
+
+	private Timer weFailedTimeout;
+
+	private SignalConnection connectFinishedConnection;
+	private SignalConnection dataWrittenConnection;
+	private SignalConnection dataReadConnection;
+	private SignalConnection disconnectedConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public SOCKS5BytestreamClientSession(Connection connection, final HostAddressPort addressPort, final String destination, TimerFactory timerFactory) {
+		this.connection = connection;
+		this.addressPort = addressPort;
+		this.destination = destination;
+		this.state = State.Initial;
+		this.chunkSize = 131072;
+		weFailedTimeout = timerFactory.createTimer(3000);
+		weFailedTimeout.onTick.connect(new Slot() {
+			@Override
+			public void call() {
+				handleWeFailedTimeout();
+			}
+		});
+	}
+
+	public void start() {
+		assert(state == State.Initial);
+		logger_.fine("Trying to connect via TCP to " + addressPort.toString() + ".\n");
+		weFailedTimeout.start();
+		connectFinishedConnection = connection.onConnectFinished.connect(new Slot1<Boolean>() {
+			@Override
+			public void call(Boolean b) {
+				handleConnectFinished(b);
+			}
+		});
+		connection.connect(addressPort);
+	}
+
+	public void stop() {
+		logger_.fine("\n");
+		if (state.description < State.Ready.description) {
+			weFailedTimeout.stop();
+		}
+		if (state == State.Finished) {
+			return;
+		}
+		closeConnection();
+		readBytestream = null;
+		state = State.Finished;		
+	}
+
+	public void startReceiving(WriteBytestream writeStream) {
+		if (state == State.Ready) {
+			state = State.Reading;
+			writeBytestream = writeStream;
+			writeBytestream.write(unprocessedData);
+			//onBytesReceived(unprocessedData.size());
+			unprocessedData.clear();
+		} else {
+			logger_.fine("Session isn't ready for transfer yet!\n");
+		}
+	}
+
+	public void startSending(ReadBytestream readStream) {
+		if (state == State.Ready) {
+			state = State.Writing;
+			readBytestream = readStream;
+			dataWrittenConnection = connection.onDataWritten.connect(new Slot() {
+				@Override
+				public void call() {
+					sendData();
+				}
+			});
+			sendData();
+		} else {
+			logger_.fine("Session isn't ready for transfer yet!\n");
+		}
+	}
+
+	public HostAddressPort getAddressPort() {
+		return addressPort;
+	}
+
+	public Signal1<Boolean /*error*/> onSessionReady = new Signal1<Boolean>();
+
+	public Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+	public Signal1<Integer> onBytesSent = new Signal1<Integer>();
+	//public boost::signal<void (size_t)> onBytesReceived;
+
+	private void process() {
+		logger_.fine("unprocessedData.size(): " + unprocessedData.getSize() + "\n");
+		ByteArray bndAddress = new ByteArray();
+		switch(state) {
+			case Initial:
+				hello();
+				break;
+			case Hello:
+				if (unprocessedData.getSize() > 1) {
+					char version = (char)unprocessedData.getData()[0];
+					char authMethod = (char)unprocessedData.getData()[1];
+					if (version != 5 || authMethod != 0) {
+						// signal failure to upper level
+						finish(true);
+						return;
+					}
+					unprocessedData.clear();
+					authenticate();
+				}
+				break;
+			case Authenticating:
+				if (unprocessedData.getSize() < 5) {
+					// need more data to start progressing
+					break;
+				}
+				if (unprocessedData.getData()[0] != (byte)0x05) {
+					// wrong version
+					// disconnect & signal failure
+					finish(true);
+					break;
+				}
+				if (unprocessedData.getData()[1] != (byte)0x00) {
+					// no success
+					// disconnect & signal failure
+					finish(true);
+					break;
+				}
+				if (unprocessedData.getData()[3] != (byte)0x03) {
+					// we expect x'03' = DOMAINNAME here
+					// disconnect & signal failure
+					finish(true);
+					break;
+				}
+				if (((int)unprocessedData.getData()[4]) + 1 > unprocessedData.getSize() + 5) {
+					// complete domainname and port not available yet
+					break;
+				}
+				//-----bndAddress = new ByteArray(&vecptr(unprocessedData)[5], unprocessedData[4]);
+				if (unprocessedData.getData()[unprocessedData.getData()[4] + 5] != 0 && new ByteArray(destination).equals(bndAddress)) {
+					// we expect a 0 as port
+					// disconnect and fail
+					finish(true);
+				}
+				unprocessedData.clear();
+				state = State.Ready;
+				logger_.fine("session ready\n");
+				// issue ready signal so the bytestream can be used for reading or writing
+				weFailedTimeout.stop();
+				onSessionReady.emit(false);
+				break;
+			case Ready:
+				logger_.fine("Received further data in Ready state.\n");
+				break;
+			case Reading:
+			case Writing:
+			case Finished:
+				logger_.fine("Unexpected receive of data. Current state: " + state + "\n");
+				logger_.fine("Data: " + Hexify.hexify(unprocessedData) + "\n");
+				unprocessedData.clear();
+				//assert(false);
+		}
+	}
+
+	private void hello() {
+		// Version 5, 1 auth method, No authentication
+		final SafeByteArray hello = new SafeByteArray(new byte[]{0x05, 0x01, 0x00});
+		connection.write(hello);
+		state = State.Hello;
+	}
+
+	private void authenticate() {
+		logger_.fine("\n");
+		SafeByteArray header = new SafeByteArray(new byte[]{0x05, 0x01, 0x00, 0x03});
+		SafeByteArray message = header;
+		String destinationlength = Integer.toString(destination.length());
+		message.append(new SafeByteArray(destinationlength));
+		authenticateAddress = new ByteArray(destination);
+		message.append(authenticateAddress);
+		message.append(new SafeByteArray(new byte[]{0x00, 0x00})); // 2 byte for port
+		connection.write(message);
+		state = State.Authenticating;		
+	}
+
+	private void handleConnectFinished(boolean error) {
+		connectFinishedConnection.disconnect();
+		if (error) {
+			logger_.fine("Failed to connect via TCP to " + addressPort.toString() + "." + "\n");
+			finish(true);
+		} else {
+			logger_.fine("Successfully connected via TCP" + addressPort.toString() + "." + "\n");
+			disconnectedConnection = connection.onDisconnected.connect(new Slot1<Connection.Error>() {
+				@Override
+				public void call(Connection.Error e) {
+					handleDisconnected(e);
+				}
+			});
+			dataReadConnection = connection.onDataRead.connect(new Slot1<SafeByteArray>() {
+				@Override
+				public void call(SafeByteArray b) {
+					handleDataRead(b);
+				}
+			});
+			weFailedTimeout.stop();
+			weFailedTimeout.start();
+			process();
+		}
+	}
+
+	private void handleDataRead(SafeByteArray data) {
+		logger_.fine("state: " + state + " data.size() = " + data.getSize() + "\n");
+		if (state != State.Reading) {
+			unprocessedData.append(data);
+			process();
+		}
+		else {
+			//---------writeBytestream.write(new ByteArray(vecptr(*data), data.size()));
+			//onBytesReceived(data.size());
+		}
+	}
+
+	private void handleDisconnected(final Connection.Error error) {
+		logger_.fine((error != null ? (error == Connection.Error.ReadError ? "Read Error" : "Write Error") : "No Error") + "\n");
+		if (error != null) {
+			finish(true);
+		}
+	}
+
+	private void handleWeFailedTimeout() {
+		logger_.fine("Failed due to timeout!\n");
+		finish(true);
+	}
+
+	private void finish(boolean error) {
+		logger_.fine("\n");
+		if (state.description < State.Ready.description) {
+			weFailedTimeout.stop(); }
+		closeConnection();
+		readBytestream = null;
+		if (State.Initial.equals(state) || State.Hello.equals(state) || State.Authenticating.equals(state)) {
+			onSessionReady.emit(true);
+		}
+		else {
+			state = State.Finished;
+			if (error) {
+				onFinished.emit(new FileTransferError(FileTransferError.Type.ReadError));
+			} else {
+				onFinished.emit(null);
+			}
+		}
+	}
+
+	private void sendData() {
+		if (!readBytestream.isFinished()) {
+			//try {
+				ByteArray dataToSend = readBytestream.read((int)(chunkSize));
+				connection.write(new SafeByteArray(dataToSend));
+				onBytesSent.emit(dataToSend.getSize());
+			//}
+			//catch (BytestreamException e) {
+			//	finish(true);
+			//}
+		}
+		else {
+			finish(false);
+		}
+	}
+
+	private void closeConnection() {
+		connectFinishedConnection.disconnect();
+		dataWrittenConnection.disconnect();
+		dataReadConnection.disconnect();
+		disconnectedConnection.disconnect();
+		connection.disconnect();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxiesManager.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxiesManager.java
new file mode 100644
index 0000000..14c7ea3
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxiesManager.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.network.Connection;
+import com.isode.stroke.network.ConnectionFactory;
+import com.isode.stroke.network.DomainNameResolver;
+import com.isode.stroke.network.TimerFactory;
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.network.DomainNameResolveError;
+import com.isode.stroke.network.DomainNameAddressQuery;
+import com.isode.stroke.network.HostAddress;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.signals.Signal;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.elements.S5BProxyRequest;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+import java.util.Collection;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ *	- manages list of working S5B proxies
+ *	- creates initial connections (for the candidates you provide)
+ */
+public class SOCKS5BytestreamProxiesManager {
+
+	private ConnectionFactory connectionFactory_;
+	private TimerFactory timerFactory_;
+	private DomainNameResolver resolver_;
+	private IQRouter iqRouter_;
+	private JID serviceRoot_;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+	private SignalConnection onSessionReadyConnection;
+	private SignalConnection onFinishedConnection;
+
+	private static class Pair {
+		public JID jid;
+		public SOCKS5BytestreamClientSession sock5;
+
+		public Pair(JID j, SOCKS5BytestreamClientSession c) {this.jid = j; this.sock5 = c; }
+	}
+
+	private Map<String, Collection<Pair> > proxySessions_ = new HashMap<String, Collection<Pair> >();
+
+	private SOCKS5BytestreamProxyFinder proxyFinder_;
+
+	private Collection<S5BProxyRequest> localS5BProxies_;
+
+	public SOCKS5BytestreamProxiesManager(ConnectionFactory connFactory, TimerFactory timeFactory, DomainNameResolver resolver, IQRouter iqRouter, final JID serviceRoot) {
+		connectionFactory_ = connFactory;
+		timerFactory_ = timeFactory;
+		resolver_ = resolver;
+		iqRouter_ = iqRouter;
+		serviceRoot_ = serviceRoot;
+	}
+
+	public void addS5BProxy(S5BProxyRequest proxy) {
+		if (proxy != null) {
+			//SWIFT_LOG_ASSERT(HostAddress(proxy.getStreamHost().get().host).isValid(), warning) << std::endl;
+			if (localS5BProxies_ == null) {
+				localS5BProxies_ = new Vector<S5BProxyRequest>();
+			}
+			localS5BProxies_.add(proxy);
+		}
+	}
+
+	/*
+	 * Returns a list of external S5B proxies. If the optinal return value is not initialized a discovery process has been started and
+	 * onDiscoveredProxiesChanged signal will be emitted when it is finished.
+	 */
+	public Collection<S5BProxyRequest> getOrDiscoverS5BProxies() {
+		if (localS5BProxies_ == null && proxyFinder_ == null) {
+			queryForProxies();
+		}
+		return localS5BProxies_;
+	}
+
+	public void connectToProxies(final String sessionID) {
+		logger_.fine("session ID: " + sessionID + "\n");
+		Collection<Pair> clientSessions = new Vector<Pair>();
+
+		if (localS5BProxies_ != null) {
+			for(S5BProxyRequest proxy : localS5BProxies_) {
+				Connection conn = connectionFactory_.createConnection();
+
+				HostAddressPort addressPort = new HostAddressPort(new HostAddress(proxy.getStreamHost().host), proxy.getStreamHost().port);
+				//SWIFT_LOG_ASSERT(addressPort.isValid(), warning) << std::endl;
+				final SOCKS5BytestreamClientSession session = new SOCKS5BytestreamClientSession(conn, addressPort, sessionID, timerFactory_);
+				final JID proxyJid = proxy.getStreamHost().jid;
+				clientSessions.add(new Pair(proxyJid, session));
+				onSessionReadyConnection = session.onSessionReady.connect(new Slot1<Boolean>() {
+					@Override
+					public void call(Boolean b) {
+						handleProxySessionReady(sessionID, proxyJid, session, b);
+					}
+				});
+				onFinishedConnection = session.onFinished.connect(new Slot1<FileTransferError>() {
+					@Override
+					public void call(FileTransferError e) {
+						handleProxySessionFinished(sessionID, proxyJid, session, e);
+					}
+				});
+				session.start();
+			}
+		}
+
+		proxySessions_.put(sessionID, clientSessions);
+	}
+
+	public SOCKS5BytestreamClientSession getProxySessionAndCloseOthers(final JID proxyJID, final String sessionID) {
+		// checking parameters
+		if (!proxySessions_.containsKey(sessionID)) {
+			return null;
+		}
+
+		// get active session
+		SOCKS5BytestreamClientSession activeSession = null;
+		for(Pair i : proxySessions_.get(sessionID)) {
+			i.sock5.onSessionReady.disconnectAll();
+			i.sock5.onFinished.disconnectAll();
+			if (i.jid.equals(proxyJID) && activeSession == null) {
+				activeSession = i.sock5;
+			}
+			else {
+				i.sock5.stop();
+			}
+		}
+
+		proxySessions_.remove(sessionID);
+
+		return activeSession;
+	}
+
+	public SOCKS5BytestreamClientSession createSOCKS5BytestreamClientSession(HostAddressPort addressPort, final String destAddr) {
+		SOCKS5BytestreamClientSession connection = new SOCKS5BytestreamClientSession(connectionFactory_.createConnection(), addressPort, destAddr, timerFactory_);
+		return connection;
+	}
+
+	public final Signal onDiscoveredProxiesChanged = new Signal();
+
+	private void handleProxyFound(final S5BProxyRequest proxy) {
+		if (proxy != null) {
+			if (new HostAddress(proxy.getStreamHost().host).isValid()) {
+				addS5BProxy(proxy);
+				onDiscoveredProxiesChanged.emit();
+			}
+			else {
+				DomainNameAddressQuery resolveRequest = resolver_.createAddressQuery(proxy.getStreamHost().host);
+				resolveRequest.onResult.connect(new Slot2<Collection<HostAddress>, DomainNameResolveError>() {
+					@Override
+					public void call(Collection<HostAddress> c, DomainNameResolveError d) {
+						handleNameLookupResult(c, d, proxy);
+					}
+				});
+				resolveRequest.run();
+			}
+		}
+		else {
+			onDiscoveredProxiesChanged.emit();
+		}
+		proxyFinder_.stop();
+		proxyFinder_ = null;
+	}
+
+	private void handleNameLookupResult(final Collection<HostAddress> addresses, DomainNameResolveError error, S5BProxyRequest proxy) {
+		if (error != null) {
+			onDiscoveredProxiesChanged.emit();
+		}
+		else {
+			if (addresses.isEmpty()) {
+				logger_.warning("S5B proxy hostname does not resolve.\n");
+				onDiscoveredProxiesChanged.emit();
+			}
+			else {
+				// generate proxy per returned address
+				for (final HostAddress address : addresses) {
+					S5BProxyRequest.StreamHost streamHost = proxy.getStreamHost();
+					S5BProxyRequest proxyForAddress = proxy;
+					streamHost.host = address.toString();
+					proxyForAddress.setStreamHost(streamHost);
+					addS5BProxy(proxyForAddress);
+				}
+				onDiscoveredProxiesChanged.emit();
+			}
+		}
+	}
+
+	private void queryForProxies() {
+		proxyFinder_ = new SOCKS5BytestreamProxyFinder(serviceRoot_, iqRouter_);
+
+		proxyFinder_.onProxyFound.connect(new Slot1<S5BProxyRequest>() {
+			@Override
+			public void call(S5BProxyRequest s) {
+				handleProxyFound(s);
+			}
+		});
+		proxyFinder_.start();
+	}
+
+	private void handleProxySessionReady(final String sessionID, final JID jid, SOCKS5BytestreamClientSession session, boolean error) {
+		onSessionReadyConnection.disconnect();
+		if (!error) {
+			// The SOCKS5 bytestream session to the proxy succeeded; stop and remove other sessions.
+			if (proxySessions_.containsKey(sessionID)) {
+				for(Pair i : proxySessions_.get(sessionID)) {
+					if ((i.jid.equals(jid)) && (!i.sock5.equals(session))) {
+						i.sock5.stop();
+						proxySessions_.get(sessionID).remove(i); //Swiften assigns i, so that iterator points to the next element.
+					}
+				}
+			}
+		}
+	}
+
+	private void handleProxySessionFinished(final String sessionID, final JID jid, SOCKS5BytestreamClientSession session, FileTransferError error) {
+		onFinishedConnection.disconnect();
+		if (error != null) {
+			// The SOCKS5 bytestream session to the proxy failed; remove it.
+			if (proxySessions_.containsKey(sessionID)) {
+				for(Pair i : proxySessions_.get(sessionID)) {
+					if ((i.jid.equals(jid)) && (i.sock5.equals(session))) {
+						i.sock5.stop();
+						proxySessions_.get(sessionID).remove(i); //Swiften assigns i, so that iterator points to the next element.
+						break;
+					}
+				}
+			}
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxyFinder.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxyFinder.java
new file mode 100644
index 0000000..d856a2f
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamProxyFinder.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.elements.S5BProxyRequest;
+import com.isode.stroke.elements.ErrorPayload;
+import com.isode.stroke.elements.DiscoInfo;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.disco.DiscoServiceWalker;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot2;
+import com.isode.stroke.jid.JID;
+import java.util.Vector;
+import java.util.logging.Logger;
+
+/*
+ * This class is designed to find possible SOCKS5 bytestream proxies which are used for peer-to-peer data transfers in
+ * restrictive environments.
+ */
+public class SOCKS5BytestreamProxyFinder {
+
+	private JID service;
+	private IQRouter iqRouter;
+	private DiscoServiceWalker serviceWalker;
+	private Vector<GenericRequest<S5BProxyRequest> > requests = new Vector<GenericRequest<S5BProxyRequest>>();
+	private SignalConnection onServiceFoundConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public SOCKS5BytestreamProxyFinder(final JID service, IQRouter iqRouter) {
+		this.service = service;
+		this.iqRouter = iqRouter;
+	}
+
+	public void start() {
+		serviceWalker = new DiscoServiceWalker(service, iqRouter);
+		onServiceFoundConnection = serviceWalker.onServiceFound.connect(new Slot2<JID, DiscoInfo>() {
+			@Override
+			public void call(JID j, DiscoInfo d) {
+				handleServiceFound(j, d);
+			}
+		});
+		serviceWalker.beginWalk();
+	}
+
+	public void stop() {
+		serviceWalker.endWalk();
+		onServiceFoundConnection.disconnect();
+		serviceWalker = null;
+	}
+
+	public final Signal1<S5BProxyRequest> onProxyFound = new Signal1<S5BProxyRequest>();
+
+	private void sendBytestreamQuery(final JID jid) {
+		S5BProxyRequest proxyRequest = new S5BProxyRequest();
+		GenericRequest<S5BProxyRequest> request = new GenericRequest<S5BProxyRequest>(IQ.Type.Get, jid, proxyRequest, iqRouter);
+		request.onResponse.connect(new Slot2<S5BProxyRequest, ErrorPayload>() {
+			@Override
+			public void call(S5BProxyRequest s, ErrorPayload e) {
+				handleProxyResponse(s, e);
+			}
+		});
+		request.send();
+	}
+
+	private void handleServiceFound(final JID jid, DiscoInfo discoInfo) {
+		if (discoInfo.hasFeature(DiscoInfo.Bytestream)) {
+			sendBytestreamQuery(jid);
+		}
+	}
+	private void handleProxyResponse(S5BProxyRequest request, ErrorPayload error) {
+		if (error != null) {
+			logger_.fine("ERROR\n");
+		} else {
+			if (request != null) {
+				onProxyFound.emit(request);
+			} else {
+				//assert(false);
+			}
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamRegistry.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamRegistry.java
new file mode 100644
index 0000000..7f131e5
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamRegistry.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2010-2013 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.base.IDGenerator;
+import java.util.Set;
+import java.util.HashSet;
+
+public class SOCKS5BytestreamRegistry {
+
+	private Set<String> availableBytestreams = new HashSet<String>();
+	private IDGenerator idGenerator = new IDGenerator();
+
+	public SOCKS5BytestreamRegistry() {
+
+	}
+
+	public void setHasBytestream(final String destination, boolean b) {
+		if (b) {
+			availableBytestreams.add(destination);
+		}
+		else {
+			availableBytestreams.remove(destination);
+		}
+	}
+
+	public boolean hasBytestream(final String destination) {
+		return availableBytestreams.contains(destination);
+	}
+
+	/**
+	 * Generate a new session ID to use for new S5B streams.
+	 */
+	public String generateSessionID() {
+		return idGenerator.generateID();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServer.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServer.java
new file mode 100644
index 0000000..3a745e2
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServer.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.network.ConnectionServer;
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.network.Connection;
+import com.isode.stroke.jid.JID;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Slot;
+import java.util.Vector;
+
+public class SOCKS5BytestreamServer {
+
+	private ConnectionServer connectionServer;
+	private SOCKS5BytestreamRegistry registry;
+	private Vector<SOCKS5BytestreamServerSession> sessions = new Vector<SOCKS5BytestreamServerSession>();
+	private SignalConnection onNewConnectionConn;
+	private SignalConnection onFinishedConnection;
+
+	public SOCKS5BytestreamServer(ConnectionServer connectionServer, SOCKS5BytestreamRegistry registry) {
+		this.connectionServer = connectionServer;
+		this.registry = registry;
+	}
+
+	public HostAddressPort getAddressPort() {
+		return connectionServer.getAddressPort();
+	}
+
+	public void start() {
+		onNewConnectionConn = connectionServer.onNewConnection.connect(new Slot1<Connection>() {
+			@Override
+			public void call(Connection c) {
+				handleNewConnection(c);
+			}
+		});
+	}
+
+	public void stop() {
+		onNewConnectionConn.disconnect();
+		for (SOCKS5BytestreamServerSession session : sessions) {
+			session.onFinished.disconnectAll();
+			session.stop();
+		}
+		sessions.clear();
+	}
+
+	public Vector<SOCKS5BytestreamServerSession> getSessions(final String streamID) {
+		Vector<SOCKS5BytestreamServerSession> result = new Vector<SOCKS5BytestreamServerSession>();
+		for (SOCKS5BytestreamServerSession session : sessions) {
+			if (session.getStreamID().equals(streamID)) {
+				result.add(session);
+			}
+		}
+		return result;
+	}
+
+	private void handleNewConnection(Connection connection) {
+		final SOCKS5BytestreamServerSession session = new SOCKS5BytestreamServerSession(connection, registry);
+		onFinishedConnection = session.onFinished.connect(new Slot1<FileTransferError>() {
+			@Override
+			public void call(FileTransferError e) {
+				handleSessionFinished(session);
+			}
+		});
+		sessions.add(session);
+		session.start();
+	}
+
+	private void handleSessionFinished(SOCKS5BytestreamServerSession session) {
+		while(sessions.contains(session)) {
+			sessions.remove(session);
+		}
+		onFinishedConnection.disconnect();
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerManager.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerManager.java
new file mode 100644
index 0000000..729193a
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerManager.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2012-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2011 Tobias Markmann
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.network.ConnectionServer;
+import com.isode.stroke.network.ConnectionServerFactory;
+import com.isode.stroke.network.NATTraverser;
+import com.isode.stroke.network.NetworkInterface;
+import com.isode.stroke.network.NATPortMapping;
+import com.isode.stroke.network.NetworkEnvironment;
+import com.isode.stroke.network.NATTraversalGetPublicIPRequest;
+import com.isode.stroke.network.NATTraversalForwardPortRequest;
+import com.isode.stroke.network.NATTraversalRemovePortForwardingRequest;
+import com.isode.stroke.network.HostAddress;
+import com.isode.stroke.network.HostAddressPort;
+import java.util.Vector;
+import java.util.logging.Logger;
+
+public class SOCKS5BytestreamServerManager {
+
+	public static final int LISTEN_PORTS_BEGIN = 10000;
+	public static final int LISTEN_PORTS_END = 11000;
+
+	private SOCKS5BytestreamRegistry bytestreamRegistry;
+	private ConnectionServerFactory connectionServerFactory;
+	private NetworkEnvironment networkEnvironment;
+	private NATTraverser natTraverser;
+	private enum State { Start, Initializing, Initialized };
+	private State state; 
+	private SOCKS5BytestreamServer server;
+	private ConnectionServer connectionServer;
+	private int connectionServerPort;
+
+	private NATTraversalGetPublicIPRequest getPublicIPRequest;
+	private NATTraversalForwardPortRequest forwardPortRequest;
+	private NATTraversalRemovePortForwardingRequest unforwardPortRequest;
+	private HostAddress publicAddress;
+	private NATPortMapping portMapping;
+	private boolean attemptedPortMapping_;
+
+	private SOCKS5BytestreamServerResourceUser s5bServerResourceUser_;
+	private SOCKS5BytestreamServerPortForwardingUser s5bServerPortForwardingUser_;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public SOCKS5BytestreamServerManager(SOCKS5BytestreamRegistry bytestreamRegistry, ConnectionServerFactory connectionServerFactory, NetworkEnvironment networkEnvironment, NATTraverser natTraverser) {
+		this.bytestreamRegistry = bytestreamRegistry;
+		this.connectionServerFactory = connectionServerFactory;
+		this.networkEnvironment = networkEnvironment;
+		this.natTraverser = natTraverser;
+		this.state = State.Start;
+		this.server = null;
+		this.attemptedPortMapping_ = false;
+	}
+
+	/**
+	* User should call delete to free the resources.
+	*/
+	public void delete() {
+		//SWIFT_LOG_ASSERT(!connectionServer, warning) << std::endl;
+		//SWIFT_LOG_ASSERT(!getPublicIPRequest, warning) << std::endl;
+		//SWIFT_LOG_ASSERT(!forwardPortRequest, warning) << std::endl;
+		//SWIFT_LOG_ASSERT(state == Start, warning) << std::endl;
+		if (portMapping != null && unforwardPortRequest == null) {
+			//SWIFT_LOG(warning) << "Port forwarding still alive. Trying to remove it now." << std::endl;
+			unforwardPortRequest = natTraverser.createRemovePortForwardingRequest(portMapping.getLocalPort(), portMapping.getPublicPort());
+			unforwardPortRequest.start();
+		}
+	}
+
+	protected void finalize() throws Throwable {
+		try {
+			delete();
+		}
+		finally {
+			super.finalize();
+		}
+	}
+
+	public SOCKS5BytestreamServerResourceUser aquireResourceUser() {
+		SOCKS5BytestreamServerResourceUser resourceUser = null;
+		if (s5bServerResourceUser_ == null) {
+			resourceUser = new SOCKS5BytestreamServerResourceUser(this);
+			s5bServerResourceUser_ = resourceUser;
+		}
+		else {
+			resourceUser = s5bServerResourceUser_;
+		}
+		return resourceUser;
+	}
+
+	public SOCKS5BytestreamServerPortForwardingUser aquirePortForwardingUser() {
+		SOCKS5BytestreamServerPortForwardingUser portForwardingUser = null;
+		if (s5bServerPortForwardingUser_ == null) {
+			portForwardingUser = new SOCKS5BytestreamServerPortForwardingUser(this);
+			s5bServerPortForwardingUser_ = portForwardingUser;
+		}
+		else {
+			portForwardingUser = s5bServerPortForwardingUser_;
+		}
+		return portForwardingUser;
+	}
+
+	public void stop() {
+		if (getPublicIPRequest != null) {
+			getPublicIPRequest.stop();
+			getPublicIPRequest = null;
+		}
+		if (forwardPortRequest != null) {
+			forwardPortRequest.stop();
+			forwardPortRequest = null;
+		}
+		if (server != null) {
+			server.stop();
+			server = null;
+		}
+		if (connectionServer != null) {
+			connectionServer.stop();
+			connectionServer = null;
+		}
+
+		state = State.Start;
+	}
+			
+	public Vector<HostAddressPort> getHostAddressPorts() {
+		Vector<HostAddressPort> result = new Vector<HostAddressPort>();
+		if (connectionServer != null) {
+			Vector<NetworkInterface> networkInterfaces = networkEnvironment.getNetworkInterfaces();
+			for (final NetworkInterface networkInterface : networkInterfaces) {
+				for (final HostAddress address : networkInterface.getAddresses()) {
+					result.add(new HostAddressPort(address, connectionServerPort));
+				}
+			}
+		}
+		return result;
+	}
+
+	public Vector<HostAddressPort> getAssistedHostAddressPorts() {
+		Vector<HostAddressPort> result = new Vector<HostAddressPort>();
+		if (publicAddress != null && portMapping != null) {
+			result.add(new HostAddressPort(publicAddress, portMapping.getPublicPort()));
+		}
+		return result;
+	}
+
+	public SOCKS5BytestreamServer getServer()  {
+		return server;
+	}
+
+	boolean isInitialized() {
+		return State.Initialized.equals(state);
+	}
+
+	void initialize() {
+		if (State.Start.equals(state)) {
+			state = State.Initializing;
+
+			// Find a port to listen on
+			assert(connectionServer == null);
+			int port;
+			for (port = LISTEN_PORTS_BEGIN; port < LISTEN_PORTS_END; ++port) {
+				logger_.fine("Trying to start server on port " + port + "\n");
+				connectionServer = connectionServerFactory.createConnectionServer(new HostAddress("0.0.0.0"), port);
+				ConnectionServer.Error error = connectionServer.tryStart();
+				if (error == null) {
+					break;
+				}
+				else if (!ConnectionServer.Error.Conflict.equals(error)) {
+					logger_.fine("Error starting server\n");
+					onInitialized.emit(false);
+					return;
+				}
+				connectionServer = null;
+			}
+			if (connectionServer == null) {
+				logger_.fine("Unable to find an open port\n");
+				onInitialized.emit(false);
+				return;
+			}
+			logger_.fine("Server started succesfully\n");
+			connectionServerPort = port;
+
+			// Start bytestream server. Should actually happen before the connectionserver is started
+			// but that doesn't really matter here.
+			assert(server == null);
+			server = new SOCKS5BytestreamServer(connectionServer, bytestreamRegistry);
+			server.start();
+			checkInitializeFinished();
+		}
+	}
+
+	boolean isPortForwardingReady() {
+		return attemptedPortMapping_ && getPublicIPRequest == null && forwardPortRequest == null;
+	}
+
+	void setupPortForwarding() {
+		assert(server != null);
+		attemptedPortMapping_ = true;
+
+		// Retrieve public addresses
+		assert(getPublicIPRequest == null);
+		publicAddress = null;
+		if ((natTraverser.createGetPublicIPRequest() != null)) {
+			getPublicIPRequest = natTraverser.createGetPublicIPRequest();
+			getPublicIPRequest.onResult.connect(new Slot1<HostAddress>() {
+				@Override
+				public void call(HostAddress a) {
+					handleGetPublicIPResult(a);
+				}
+			});
+			getPublicIPRequest.start();
+		}
+
+		// Forward ports
+		int port = server.getAddressPort().getPort();
+		assert(forwardPortRequest == null);
+		portMapping = null;
+		if ((natTraverser.createForwardPortRequest(port, port) != null)) {
+			forwardPortRequest = natTraverser.createForwardPortRequest(port, port);
+			forwardPortRequest.onResult.connect(new Slot1<NATPortMapping>() {
+				@Override
+				public void call(NATPortMapping n) {
+					handleForwardPortResult(n);
+				}
+			});
+			forwardPortRequest.start();
+		}
+	}
+
+	void removePortForwarding() {
+		// remove port forwards
+		if (portMapping != null) {
+			unforwardPortRequest = natTraverser.createRemovePortForwardingRequest(portMapping.getLocalPort(), portMapping.getPublicPort());
+			unforwardPortRequest.onResult.connect(new Slot1<Boolean>() {
+				@Override
+				public void call(Boolean b) {
+					handleUnforwardPortResult(b);
+				}
+			});
+			unforwardPortRequest.start();
+		}
+	}
+
+	void checkInitializeFinished() {
+		assert(State.Initializing.equals(state));
+		state = State.Initialized;
+		onInitialized.emit(true);
+	}
+
+	void handleGetPublicIPResult(HostAddress address) {
+		if (address != null) {
+			logger_.fine("Public IP discovered as " + address.toString() + ".\n");
+		} 
+		else {
+			logger_.fine("No public IP discoverable.\n");
+		}
+
+		publicAddress = address;
+
+		getPublicIPRequest.stop();
+		getPublicIPRequest = null;
+	}
+
+	void handleForwardPortResult(NATPortMapping mapping) {
+		if (mapping != null) {
+			logger_.fine("Mapping port was successful.\n");
+		} 
+		else {
+			logger_.fine("Mapping port has failed.\n");
+		}
+
+		portMapping = mapping;
+		onPortForwardingSetup.emit(mapping != null);
+
+		forwardPortRequest.stop();
+		forwardPortRequest = null;
+	}
+
+	void handleUnforwardPortResult(Boolean result) {
+		if (result != null && result) {
+			portMapping = null;
+		}
+		else {
+			logger_.warning("Failed to remove port forwarding.\n");
+		}
+		attemptedPortMapping_ = false;
+		unforwardPortRequest = null;
+	}
+
+	Signal1<Boolean/* success */> onInitialized = new Signal1<Boolean>();
+	Signal1<Boolean/* success */> onPortForwardingSetup = new Signal1<Boolean>();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerPortForwardingUser.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerPortForwardingUser.java
new file mode 100644
index 0000000..dc3c3b7
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerPortForwardingUser.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.SignalConnection;
+
+public class SOCKS5BytestreamServerPortForwardingUser {
+
+	private SOCKS5BytestreamServerManager s5bServerManager_;
+	private SignalConnection onPortForwardingSetupConnection_;
+
+	public SOCKS5BytestreamServerPortForwardingUser(SOCKS5BytestreamServerManager s5bServerManager) {
+		this.s5bServerManager_ = s5bServerManager;
+		// the server should be initialized, so we know what port to setup a forward for
+		assert(s5bServerManager != null);
+		if (s5bServerManager_.isPortForwardingReady()) {
+			onSetup.emit(!s5bServerManager_.getAssistedHostAddressPorts().isEmpty());
+		}
+		else {
+			onPortForwardingSetupConnection_ = s5bServerManager_.onPortForwardingSetup.connect(new Slot1<Boolean>() {
+				@Override
+				public void call(Boolean s) {
+					handleServerManagerPortForwardingSetup(s);
+				}
+			});
+			s5bServerManager_.setupPortForwarding();
+		}
+	}
+
+	/**
+	* User should call delete to free the resources.
+	*/
+	public void delete() {
+		if (s5bServerManager_.isPortForwardingReady()) {
+			s5bServerManager_.removePortForwarding();
+		}
+	}
+
+	protected void finalize() throws Throwable {
+		try {
+			delete();
+		}
+		finally {
+			super.finalize();
+		}
+	}
+
+	public boolean isForwardingSetup() {
+		return s5bServerManager_.isPortForwardingReady();
+	}
+
+	public Signal1<Boolean /* success */> onSetup = new Signal1<Boolean>();
+
+	private void handleServerManagerPortForwardingSetup(boolean successful) {
+		onSetup.emit(successful);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerResourceUser.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerResourceUser.java
new file mode 100644
index 0000000..acb8af1
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerResourceUser.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Slot1;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.SignalConnection;
+
+public class SOCKS5BytestreamServerResourceUser {
+
+	private SOCKS5BytestreamServerManager s5bServerManager_;
+	private SignalConnection onInitializedConnection_;
+
+	public SOCKS5BytestreamServerResourceUser(SOCKS5BytestreamServerManager s5bServerManager) {
+		this.s5bServerManager_ = s5bServerManager;
+		assert(s5bServerManager_ == null);
+		onInitializedConnection_ = s5bServerManager_.onInitialized.connect(new Slot1<Boolean>() {
+			@Override
+			public void call(Boolean b) {
+				handleServerManagerInitialized(b);
+			}
+		});
+		s5bServerManager_.initialize();
+	}
+
+	/**
+	* User should call delete to free the resources.
+	*/
+	public void delete() {
+		if (s5bServerManager_ != null) {
+			s5bServerManager_.stop();
+		}
+	}
+
+	protected void finalize() throws Throwable {
+		try {
+			delete();
+		}
+		finally {
+			super.finalize();
+		}
+	}
+
+	public boolean isInitialized() {
+		return s5bServerManager_.isInitialized();
+	}
+
+	public Signal1<Boolean /* success */> onSuccessfulInitialized = new Signal1<Boolean>();
+
+	private void handleServerManagerInitialized(boolean successfulInitialize) {
+		onSuccessfulInitialized.emit(successfulInitialize);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerSession.java b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerSession.java
new file mode 100644
index 0000000..cb09ad9
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/SOCKS5BytestreamServerSession.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2010 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.network.Connection;
+import com.isode.stroke.network.HostAddressPort;
+import com.isode.stroke.base.ByteArray;
+import com.isode.stroke.base.SafeByteArray;
+import com.isode.stroke.signals.SignalConnection;
+import com.isode.stroke.signals.Signal1;
+import com.isode.stroke.signals.Signal;
+import com.isode.stroke.signals.Slot;
+import com.isode.stroke.signals.Slot1;
+import java.util.logging.Logger;
+
+public class SOCKS5BytestreamServerSession {
+
+	private Connection connection;
+	private SOCKS5BytestreamRegistry bytestreams;
+	private ByteArray unprocessedData;
+	private State state;
+	private int chunkSize;
+	private String streamID = "";
+	private ReadBytestream readBytestream;
+	private WriteBytestream writeBytestream;
+	private boolean waitingForData;
+
+	private SignalConnection disconnectedConnection;
+	private SignalConnection dataReadConnection;
+	private SignalConnection dataWrittenConnection;
+	private SignalConnection dataAvailableConnection;
+	private Logger logger_ = Logger.getLogger(this.getClass().getName());
+
+	public enum State {
+		Initial,
+		WaitingForAuthentication,
+		WaitingForRequest,
+		ReadyForTransfer,
+		ReadingData,
+		WritingData,
+		Finished
+	};
+
+	public SOCKS5BytestreamServerSession(Connection connection, SOCKS5BytestreamRegistry bytestreams) {
+		this.connection = connection;
+		this.bytestreams = bytestreams;
+		this.state = State.Initial;
+		this.chunkSize = 131072;
+		this.waitingForData = false;
+		disconnectedConnection = connection.onDisconnected.connect(new Slot1<Connection.Error>() {
+			@Override
+			public void call(Connection.Error e) {
+				handleDisconnected(e);
+			}
+		});
+	}
+
+	public void setChunkSize(int chunkSize) {
+		this.chunkSize = chunkSize;
+	}
+
+	public void start() {
+		logger_.fine("\n");
+		dataReadConnection = connection.onDataRead.connect(new Slot1<SafeByteArray>() {
+			@Override
+			public void call(SafeByteArray s) {
+				handleDataRead(s);
+			}
+		});
+		state = State.WaitingForAuthentication;
+	}
+
+	public void stop() {
+		finish(false);
+	}
+
+	public void startSending(ReadBytestream stream) {
+		if (!State.ReadyForTransfer.equals(state)) { logger_.fine("Not ready for transfer!\n"); return; }
+		readBytestream = stream;
+		state = State.WritingData;
+		dataAvailableConnection = readBytestream.onDataAvailable.connect(new Slot() {
+			@Override
+			public void call() {
+				handleDataAvailable();
+			}
+		});
+		dataWrittenConnection = connection.onDataWritten.connect(new Slot() {
+			@Override
+			public void call() {
+				sendData();
+			}
+		});
+		sendData();
+	}
+
+	public void startReceiving(WriteBytestream stream) {
+		if (!State.ReadyForTransfer.equals(state)) { logger_.fine("Not ready for transfer!\n"); return; }
+
+		writeBytestream = stream;
+		state = State.ReadingData;
+		writeBytestream.write(unprocessedData);
+		// onBytesReceived(unprocessedData.getSize());
+		unprocessedData.clear();
+	}
+
+	public HostAddressPort getAddressPort() {
+		return connection.getLocalAddress();
+	}
+
+	public Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+	public Signal1<Long> onBytesSent = new Signal1<Long>();
+	// boost::signal<void (unsigned long long)> onBytesReceived;
+
+	public String getStreamID() {
+		return streamID;
+	}
+
+	private void finish(boolean error) {
+		logger_.fine(error + " " + state + "\n");
+		if (State.Finished.equals(state)) {
+			return;
+		}
+
+		disconnectedConnection.disconnect();
+		dataReadConnection.disconnect();
+		dataWrittenConnection.disconnect();
+		dataAvailableConnection.disconnect();
+		readBytestream = null;
+		state = State.Finished;
+		if (error) {
+			onFinished.emit(new FileTransferError(FileTransferError.Type.PeerError));
+		} else {
+			onFinished.emit(null);
+		}
+	}
+
+	private void process() {
+		if (State.WaitingForAuthentication.equals(state)) {
+			if (unprocessedData.getSize() >= 2) {
+				int authCount = unprocessedData.getData()[1];
+				int i = 2;
+				while (i < 2 + authCount && i < unprocessedData.getSize()) {
+					// Skip authentication mechanism
+					++i;
+				}
+				if (i == 2 + authCount) {
+					// Authentication message is complete
+					if (i != unprocessedData.getSize()) {
+						logger_.fine("Junk after authentication mechanism\n");
+					}
+					unprocessedData.clear();
+					connection.write(new SafeByteArray(new byte[]{0x05, 0x00}));
+					state = State.WaitingForRequest;
+				}
+			}
+		}
+		else if (State.WaitingForRequest.equals(state)) {
+			if (unprocessedData.getSize() >= 5) {
+				ByteArray requestID = new ByteArray();
+				int i = 5;
+				int hostnameSize = unprocessedData.getData()[4];
+				while (i < 5 + hostnameSize && i < unprocessedData.getSize()) {
+					requestID.append(unprocessedData.getData()[i]);
+					++i;
+				}
+				// Skip the port: 2 byte large, one already skipped. Add one for comparison with size
+				i += 2;
+				if (i <= unprocessedData.getSize()) {
+					if (i != unprocessedData.getSize()) {
+						logger_.fine("Junk after authentication mechanism\n");
+					}
+					unprocessedData.clear();
+					streamID = requestID.toString();
+					boolean hasBytestream = bytestreams.hasBytestream(streamID);
+					SafeByteArray result = new SafeByteArray("0x05");
+					result.append(hasBytestream ? (byte)0x0 : (byte)0x4);
+					result.append(new ByteArray(new byte[]{0x00, 0x03}));
+					result.append(Integer.toString(requestID.getSize()));
+					result.append(requestID.append(new ByteArray(new byte[]{0x00, 0x00})));
+					if (!hasBytestream) {
+						logger_.fine("Readstream or Wrtiestream with ID " + streamID + " not found!\n");
+						connection.write(result);
+						finish(true);
+					}
+					else {
+						logger_.fine("Found stream. Sent OK.\n");
+						connection.write(result);
+						state = State.ReadyForTransfer;
+					}
+				}
+			}
+		}
+	}
+
+	private void handleDataRead(SafeByteArray data) {
+		if (!State.ReadingData.equals(state)) {
+			unprocessedData.append(data);
+			process();
+		} else {
+			writeBytestream.write(new ByteArray(data));
+			// onBytesReceived(data.size());
+		}
+	}
+
+	private void handleDisconnected(final Connection.Error error) {
+		logger_.fine((error != null ? (error.equals(Connection.Error.ReadError) ? "Read Error" : "Write Error") : "No Error") + "\n");
+		finish(error != null ? true : false);
+	}
+
+	private void handleDataAvailable() {
+		if (waitingForData) {
+			sendData();
+		}
+	}
+
+	private void sendData() {
+		if (!readBytestream.isFinished()) {
+			//try {
+				SafeByteArray dataToSend = new SafeByteArray(readBytestream.read((chunkSize)));
+				if (!dataToSend.isEmpty()) {
+					connection.write(dataToSend);
+					onBytesSent.emit((long)dataToSend.getSize());
+					waitingForData = false;
+				}
+				else {
+					waitingForData = true;
+				}
+			//}
+			//catch (BytestreamException e) {
+			//	finish(true);
+			//}
+		}
+		else {
+			finish(false);
+		}
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/StreamInitiationRequest.java b/src/com/isode/stroke/filetransfer/StreamInitiationRequest.java
new file mode 100644
index 0000000..8ea9f14
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/StreamInitiationRequest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2010-2015 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.queries.GenericRequest;
+import com.isode.stroke.queries.IQRouter;
+import com.isode.stroke.elements.StreamInitiation;
+import com.isode.stroke.elements.IQ;
+import com.isode.stroke.jid.JID;
+
+public class StreamInitiationRequest extends GenericRequest<StreamInitiation> {
+
+	public static StreamInitiationRequest create(final JID jid, StreamInitiation payload, IQRouter router) {
+		return new StreamInitiationRequest(jid, payload, router);
+	}
+
+	public static StreamInitiationRequest create(final JID from, final JID to, StreamInitiation payload, IQRouter router) {
+		return new StreamInitiationRequest(from, to, payload, router);
+	}
+
+	private StreamInitiationRequest(final JID jid, StreamInitiation payload, IQRouter router) {
+		super(IQ.Type.Set, jid, payload, router);
+	}
+
+	private StreamInitiationRequest(final JID from, final JID to, StreamInitiation payload, IQRouter router) {
+		super(IQ.Type.Set, from, to, payload, router);
+	}
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/filetransfer/TransportSession.java b/src/com/isode/stroke/filetransfer/TransportSession.java
new file mode 100644
index 0000000..b0e101d
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/TransportSession.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2013 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.signals.Signal1;
+
+public abstract class TransportSession {
+
+	public abstract void start();
+	public abstract void stop();
+
+	public final Signal1<Integer> onBytesSent = new Signal1<Integer>();
+	public final Signal1<FileTransferError> onFinished = new Signal1<FileTransferError>();
+}
diff --git a/src/com/isode/stroke/filetransfer/WriteBytestream.java b/src/com/isode/stroke/filetransfer/WriteBytestream.java
new file mode 100644
index 0000000..c243bdc
--- /dev/null
+++ b/src/com/isode/stroke/filetransfer/WriteBytestream.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2010 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+/*
+ * Copyright (c) 2015 Tarun Gupta.
+ * Licensed under the simplified BSD license.
+ * See Documentation/Licenses/BSD-simplified.txt for more information.
+ */
+
+package com.isode.stroke.filetransfer;
+
+import com.isode.stroke.base.ByteArray;
+import com.isode.stroke.signals.Signal1;
+
+public abstract class WriteBytestream {
+
+	public abstract void write(final ByteArray b);
+
+	public final Signal1<ByteArray> onWrite = new Signal1<ByteArray>();
+}
+\ No newline at end of file
diff --git a/src/com/isode/stroke/jingle/Jingle.java b/src/com/isode/stroke/jingle/Jingle.java
index db041b8..8e78789 100644
--- a/src/com/isode/stroke/jingle/Jingle.java
+++ b/src/com/isode/stroke/jingle/Jingle.java
@@ -16,8 +16,8 @@ import com.isode.stroke.elements.Payload;
 import java.util.Vector;
 
 public class Jingle {
-
-	public <T extends Payload> JingleContentPayload getContentWithDescription(final Vector<JingleContentPayload> contents, T payload) {
+    
+	public static <T extends Payload> JingleContentPayload getContentWithDescription(final Vector<JingleContentPayload> contents, T payload) {
 		for (JingleContentPayload jingleContentPayload : contents) {
 			if (jingleContentPayload.getDescription(payload) != null) {
 				return jingleContentPayload;
diff --git a/src/com/isode/stroke/queries/GenericRequest.java b/src/com/isode/stroke/queries/GenericRequest.java
index c35b369..c9ae4a6 100644
--- a/src/com/isode/stroke/queries/GenericRequest.java
+++ b/src/com/isode/stroke/queries/GenericRequest.java
@@ -22,10 +22,29 @@ public class GenericRequest<T extends Payload> extends Request {
 
     public Signal2<T, ErrorPayload> onResponse = new Signal2<T, ErrorPayload>();
 
+    /**
+     * Create a request suitable for client use.
+     * @param type Iq type - Get or Set.
+     * @param receiver JID to send request to.
+     * @param payload Payload to send in stanza.
+     * @param router IQRouter instance for current connection.
+     */
     public GenericRequest(IQ.Type type, JID receiver, Payload payload, IQRouter router) {
         super(type, receiver, payload, router);
     }
 
+    /**
+     * Create a request suitable for component or server use. As a client, use the other constructor instead.
+     * @param type Iq type - Get or Set.
+     * @param sender JID to use in "from" of stanza.
+     * @param receiver JID to send request to.
+     * @param payload Payload to send in stanza.
+     * @param router IQRouter instance for current connection.
+     */
+    public GenericRequest(IQ.Type type, final JID sender, final JID receiver, Payload payload, IQRouter router) {
+        super(type, sender, receiver, payload, router);
+    }
+
     @Override
     public void handleResponse(Payload payload, ErrorPayload error) {
         T genericPayload = null;