+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/Network/NetworkFactories.h>

+#include <Swiften/FileTransfer/FileTransferManagerImpl.h>

+

+ jingleSessionManager = new JingleSessionManager(getIQRouter());

+ fileTransferManager = NULL;

+ delete fileTransferManager;

+ delete jingleSessionManager;

+

+void Client::handleConnected() {

+ fileTransferManager = new FileTransferManagerImpl(getJID(), jingleSessionManager, getIQRouter(), getEntityCapsProvider(), presenceOracle, getNetworkFactories()->getConnectionFactory(), getNetworkFactories()->getConnectionServerFactory(), getNetworkFactories()->getTimerFactory(), getNetworkFactories()->getPlatformNATTraversalWorker());

+}

+

+FileTransferManager* Client::getFileTransferManager() const {

+ return fileTransferManager;

+}

+

+ class FileTransferManager;

+ class JingleSessionManager;

+ class FileTransferManagerImpl;

+

+ /**

+ * Returns a FileTransferManager for the client. This is only available after the onConnected signal has been fired.

+ */

+ FileTransferManager* getFileTransferManager() const;

+ protected:

+ void handleConnected();

+

+ JingleSessionManager* jingleSessionManager;

+ FileTransferManagerImpl* fileTransferManager;

+ beautifier = new XMLBeautifier(true, true);

+ client->onDataRead.connect(boost::bind(&ClientXMLTracer::printData, this, '<', _1));

+ client->onDataWritten.connect(boost::bind(&ClientXMLTracer::printData, this, '>', _1));

+}

+

+ClientXMLTracer::~ClientXMLTracer() {

+ delete beautifier;

+ std::cerr << beautifier->beautify(byteArrayToString(ByteArray(data.begin(), data.end()))) << std::endl;

+#include <Swiften/Client/XMLBeautifier.h>

+ ~ClientXMLTracer();

+ private:

+ void printData(char direction, const SafeByteArray& data);

+ void printLine(char c);

+ XMLBeautifier *beautifier;

+ handleConnected();

+ NetworkFactories* getNetworkFactories() const {

+ return networkFactories;

+ }

+

+ /**

+ * Called before onConnected signal is emmitted.

+ */

+ virtual void handleConnected() {};

+

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <sstream>

+#include <stack>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Client/XMLBeautifier.h>

+#include <Swiften/Parser/PlatformXMLParserFactory.h>

+

+namespace Swift {

+

+XMLBeautifier::XMLBeautifier(bool indention, bool coloring) : doIndention(indention), doColoring(coloring), intLevel(0), parser(NULL), lastWasStepDown(false) {

+ factory = new PlatformXMLParserFactory();

+}

+

+XMLBeautifier::~XMLBeautifier() {

+ delete factory;

+}

+

+std::string XMLBeautifier::beautify(const std::string &text) {

+ parser = factory->createXMLParser(this);

+ intLevel = 0;

+ buffer.str(std::string());

+ parser->parse(text);

+ delete parser;

+ return buffer.str();

+}

+

+void XMLBeautifier::indent() {

+ for (int i = 0; i < intLevel; ++i) {

+ buffer << " ";

+ }

+}

+

+// all bold but reset

+const char colorBlue[] = "\x1b[01;34m";

+const char colorCyan[] = "\x1b[01;36m";

+const char colorGreen[] = "\x1b[01;32m";

+const char colorMagenta[] = "\x1b[01;35m";

+const char colorRed[] = "\x1b[01;31m";

+const char colorReset[] = "\x1b[0m";

+const char colorYellow[] = "\x1b[01;33m";

+

+

+

+std::string XMLBeautifier::styleTag(const std::string& text) const {

+ std::string result;

+ result += colorYellow;

+ result += text;

+ result += colorReset;

+ return result;

+}

+

+std::string XMLBeautifier::styleNamespace(const std::string& text) const {

+ std::string result;

+ result += colorRed;

+ result += text;

+ result += colorReset;

+ return result;

+}

+

+std::string XMLBeautifier::styleAttribute(const std::string& text) const {

+ std::string result;

+ result += colorGreen;

+ result += text;

+ result += colorReset;

+ return result;

+}

+std::string XMLBeautifier::styleValue(const std::string& text) const {

+ std::string result;

+ result += colorCyan;

+ result += text;

+ result += colorReset;

+ return result;

+}

+

+void XMLBeautifier::handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes) {

+ if (doIndention) {

+ if (intLevel) buffer << std::endl;

+ }

+ indent();

+ buffer << "<" << (doColoring ? styleTag(element) : element);

+ if (!ns.empty() && (!parentNSs.empty() && parentNSs.top() != ns)) {

+ buffer << " ";

+ buffer << (doColoring ? styleAttribute("xmlns") : "xmlns");

+ buffer << "=";

+ buffer << "\"" << (doColoring ? styleNamespace(ns) : ns) << "\"";

+ }

+ if (!attributes.getEntries().empty()) {

+ foreach(AttributeMap::Entry entry, attributes.getEntries()) {

+ buffer << " ";

+ buffer << (doColoring ? styleAttribute(entry.getAttribute().getName()) : entry.getAttribute().getName());

+ buffer << "=";

+ buffer << "\"" << (doColoring ? styleValue(entry.getValue()) : entry.getValue()) << "\"";

+ }

+ }

+ buffer << ">";

+ ++intLevel;

+ lastWasStepDown = false;

+ parentNSs.push(ns);

+}

+

+void XMLBeautifier::handleEndElement(const std::string& element, const std::string& /* ns */) {

+ --intLevel;

+ parentNSs.pop();

+ if (/*hadCDATA.top() ||*/ lastWasStepDown) {

+ if (doIndention) {

+ buffer << std::endl;

+ }

+ indent();

+ }

+ buffer << "</" << (doColoring ? styleTag(element) : element) << ">";

+ lastWasStepDown = true;

+}

+

+void XMLBeautifier::handleCharacterData(const std::string& data) {

+ buffer << data;

+ lastWasStepDown = false;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <stack>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Parser/XMLParserFactory.h>

+#include <Swiften/Parser/XMLParserClient.h>

+#include <Swiften/Parser/XMLParser.h>

+

+namespace Swift {

+

+class XMLBeautifier : public XMLParserClient {

+public:

+ XMLBeautifier(bool indention, bool coloring);

+ virtual ~XMLBeautifier();

+

+ std::string beautify(const std::string&);

+

+private:

+ void handleStartElement(const std::string& element, const std::string& ns, const AttributeMap& attributes);

+ void handleEndElement(const std::string& element, const std::string& ns);

+ void handleCharacterData(const std::string& data);

+

+private:

+ void indent();

+

+private:

+ std::string styleTag(const std::string& text) const;

+ std::string styleNamespace(const std::string& text) const;

+ std::string styleAttribute(const std::string& text) const;

+ std::string styleValue(const std::string& text) const;

+

+private:

+ bool doIndention;

+ bool doColoring;

+

+ int intLevel;

+ std::string inputBuffer;

+ std::stringstream buffer;

+ XMLParserFactory* factory;

+ XMLParser* parser;

+

+ bool lastWasStepDown;

+ std::stack<std::string> parentNSs;

+};

+}

+const std::string DiscoInfo::JingleFeature = std::string("urn:xmpp:jingle:1");

+const std::string DiscoInfo::JingleFTFeature = std::string("urn:xmpp:jingle:apps:file-transfer:3");

+const std::string DiscoInfo::JingleTransportsIBBFeature = std::string("urn:xmpp:jingle:transports:ibb:1");

+const std::string DiscoInfo::JingleTransportsS5BFeature = std::string("urn:xmpp:jingle:transports:s5b:1");

+const std::string DiscoInfo::Bytestream = std::string("http://jabber.org/protocol/bytestreams");

+ static const std::string JingleFeature;

+ static const std::string JingleFTFeature;

+ static const std::string JingleTransportsIBBFeature;

+ static const std::string JingleTransportsS5BFeature;

+ static const std::string Bytestream;

+ UnknownCreator,

+#include <vector>

+ void addOffer(const StreamInitiationFileInfo& offer) {

+ offers.push_back(offer);

+

+ const std::vector<StreamInitiationFileInfo>& getOffers() const {

+ return offers;

+ }

+

+ void addRequest(const StreamInitiationFileInfo& request) {

+ reqeusts.push_back(request);

+ }

+

+ const std::vector<StreamInitiationFileInfo>& getRequests() const {

+ return reqeusts;

+ std::vector<StreamInitiationFileInfo> offers;

+ std::vector<StreamInitiationFileInfo> reqeusts;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <map>

+#include <string>

+

+#include <Swiften/Elements/JingleDescription.h>

+

+namespace Swift {

+

+class JingleFileTransferHash : public Payload {

+public:

+ typedef std::map<std::string, std::string> HashesMap;

+public:

+ typedef boost::shared_ptr<JingleFileTransferHash> ref;

+

+ void setHash(const std::string& algo, const std::string& hash) {

+ hashes[algo] = hash;

+ }

+

+ const HashesMap& getHashes() const {

+ return hashes;

+ }

+

+private:

+ HashesMap hashes;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <vector>

+

+#include <Swiften/Elements/StreamInitiationFileInfo.h>

+#include <Swiften/Elements/Payload.h>

+

+namespace Swift {

+

+class JingleFileTransferReceived : public Payload {

+ public:

+ typedef boost::shared_ptr<JingleFileTransferReceived> ref;

+

+ void setFileInfo(const StreamInitiationFileInfo& fileInfo) {

+ this->fileInfo = fileInfo;

+ }

+

+ const StreamInitiationFileInfo& getFileInfo() const {

+ return this->fileInfo;

+ }

+ private:

+ StreamInitiationFileInfo fileInfo;

+

+};

+

+}

+#include <boost/shared_ptr.hpp>

+#include <Swiften/Base/Log.h>

+ struct Reason : public Payload {

+ UnknownType,

+ Reason() : type(UnknownType), text("") {}

+ ~Reason() {}

+ UnknownAction,

+ JinglePayload() : action(SessionTerminate), sessionID("") {

+ }

+

+

+ this->payloads.push_back(content);

+ }

+

+ void addPayload(boost::shared_ptr<Payload> payload) {

+ this->payloads.push_back(payload);

+ }

+

+ const std::vector<JingleContentPayload::ref> getContents() const {

+ return getPayloads<JingleContentPayload>();

+ }

+

+ const std::vector<boost::shared_ptr<Payload> > getPayloads() const {

+ return payloads;

+ }

+

+ template<typename T>

+ const std::vector<boost::shared_ptr<T> > getPayloads() const {

+ std::vector<boost::shared_ptr<T> > matched_payloads;

+ for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {

+ boost::shared_ptr<T> result = boost::dynamic_pointer_cast<T>(*i);

+ if (result) {

+ matched_payloads.push_back(result);

+ }

+ }

+

+ return matched_payloads;

+

+ template<typename T>

+ const boost::shared_ptr<T> getPayload() const {

+ boost::shared_ptr<T> result;

+ for (std::vector<boost::shared_ptr<Payload> >::const_iterator i = payloads.begin(); i != payloads.end(); ++i) {

+ result = boost::dynamic_pointer_cast<T>(*i);

+ if (result) {

+ return result;

+ }

+ }

+

+ return result;

+ std::vector<boost::shared_ptr<Payload> > payloads;

+#include <vector>

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/Network/HostAddressPort.h>

+ enum Mode {

+ TCPMode, // default case

+ UDPMode,

+ };

+

+ struct Candidate {

+ enum Type {

+ DirectType, // default case

+ AssistedType,

+ TunnelType,

+ ProxyType,

+ };

+

+ Candidate() : priority(0), type(DirectType) {}

+

+ std::string cid;

+ JID jid;

+ HostAddressPort hostPort;

+ int priority;

+ Type type;

+ };

+

+ struct CompareCandidate {

+ bool operator() (const JingleS5BTransportPayload::Candidate& c1, const JingleS5BTransportPayload::Candidate& c2) const {

+ if (c1.priority < c2.priority) return true;

+ return false;

+ }

+ };

+

+ public:

+ JingleS5BTransportPayload() : mode(TCPMode), candidateError(false), proxyError(false) {}

+

+ Mode getMode() const {

+ return mode;

+ }

+

+ void setMode(Mode mode) {

+ this->mode = mode;

+ }

+

+ const std::vector<Candidate>& getCandidates() {

+ return candidates;

+ }

+

+ void addCandidate(const Candidate& candidate) {

+ candidates.push_back(candidate);

+ }

+

+ void setCandidateUsed(const std::string& cid) {

+ candidateUsedCID = cid;

+ }

+

+ const std::string& getCandidateUsed() const {

+ return candidateUsedCID;

+ }

+

+ void setActivated(const std::string& cid) {

+ activatedCID = cid;

+ const std::string& getActivated() const {

+ return activatedCID;

+ void setCandidateError(bool hasError) {

+ candidateError = hasError;

+ }

+

+ bool hasCandidateError() const {

+ return candidateError;

+ }

+

+ void setProxyError(bool hasError) {

+ proxyError = hasError;

+ }

+

+ bool hasProxyError() const {

+ return proxyError;

+ }

+ public:

+ typedef boost::shared_ptr<JingleS5BTransportPayload> ref;

+

+ Mode mode;

+ std::vector<Candidate> candidates;

+

+ std::string candidateUsedCID;

+ std::string activatedCID;

+ bool candidateError;

+ bool proxyError;

+ void setSessionID(const std::string& id) {

+ sessionID = id;

+ }

+

+ const std::string& getSessionID() const {

+ return sessionID;

+ }

+

+ public:

+

+ private:

+ std::string sessionID;

+#include <boost/shared_ptr.hpp>

+

+ typedef boost::shared_ptr<Payload> ref;

+ public:

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <boost/optional.hpp>

+

+#include <Swiften/Elements/Payload.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Network/HostAddressPort.h>

+

+namespace Swift {

+

+class S5BProxyRequest : public Payload {

+public:

+ typedef boost::shared_ptr<S5BProxyRequest> ref;

+

+public:

+ struct StreamHost {

+ HostAddressPort addressPort;

+ JID jid;

+ };

+

+public:

+ const boost::optional<StreamHost>& getStreamHost() const {

+ return streamHost;

+ }

+

+ void setStreamHost(const StreamHost& streamHost) {

+ this->streamHost = boost::optional<StreamHost>(streamHost);

+ }

+

+ const std::string& getSID() const {

+ return sid;

+ }

+

+ void setSID(const std::string& sid) {

+ this->sid = sid;

+ }

+

+ const boost::optional<JID>& getActivate() const {

+ return activate;

+ }

+

+ void setActivate(const JID& activate) {

+ this->activate = activate;

+ }

+

+private:

+ boost::optional<StreamHost> streamHost;

+

+ std::string sid;

+ boost::optional<JID> activate;

+};

+

+}

+#include <Swiften/Elements/Payload.h>

+#include <boost/shared_ptr.hpp>

+#include <boost/date_time/posix_time/posix_time_types.hpp>

+

+class StreamInitiationFileInfo : public Payload {

+public:

+ typedef boost::shared_ptr<StreamInitiationFileInfo> ref;

+

+public:

+ StreamInitiationFileInfo(const std::string& name = "", const std::string& description = "", int size = 0,

+ const std::string& hash = "", const boost::posix_time::ptime &date = boost::posix_time::ptime(), const std::string& algo="md5") :

+ name(name), description(description), size(size), hash(hash), date(date), algo(algo), supportsRangeRequests(false), rangeOffset(0) {}

+

+ void setName(const std::string& name) {

+ this->name = name;;

+ }

+

+ const std::string& getName() const {

+ return this->name;

+ }

+

+ void setDescription(const std::string& description) {

+ this->description = description;

+ }

+

+ const std::string& getDescription() const {

+ return this->description;

+ }

+

+ void setSize(const boost::uintmax_t size) {

+ this->size = size;

+ }

+

+ boost::uintmax_t getSize() const {

+ return this->size;

+ }

+

+ void setHash(const std::string& hash) {

+ this->hash = hash;

+ }

+

+ const std::string& getHash() const {

+ return this->hash;

+ }

+

+ void setDate(const boost::posix_time::ptime& date) {

+ this->date = date;

+ }

+

+ const boost::posix_time::ptime& getDate() const {

+ return this->date;

+ }

+

+ void setAlgo(const std::string& algo) {

+ this->algo = algo;

+ }

+

+ const std::string& getAlgo() const {

+ return this->algo;

+ }

+

+ void setSupportsRangeRequests(const bool supportsIt) {

+ supportsRangeRequests = supportsIt;

+ }

+

+ bool getSupportsRangeRequests() const {

+ return supportsRangeRequests;

+ }

+

+ void setRangeOffset(const int offset) {

+ supportsRangeRequests = offset >= 0 ? true : false;

+ rangeOffset = offset;

+ }

+

+ int getRangeOffset() const {

+ return rangeOffset;

+ }

+

+private:

+ std::string name;

+ std::string description;

+ boost::uintmax_t size;

+ std::string hash;

+ boost::posix_time::ptime date;

+ std::string algo;

+ bool supportsRangeRequests;

+ boost::uintmax_t rangeOffset;

+};

+

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Disco/ClientDiscoManager.h>

+#include <Swiften/FileTransfer/DefaultLocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/DefaultRemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+static const std::string CLIENT_NAME = "Swiften FT Test";

+static const std::string CLIENT_NODE = "http://swift.im";

+

+ tracer = new ClientXMLTracer(client);

+ delete tracer;

+ Swift::logging = true;

+ client->getFileTransferManager()->startListeningOnPort(9999);

+ client->getFileTransferManager()->onIncomingFileTransfer.connect(boost::bind(&FileReceiver::handleIncomingFileTransfer, this, _1));

+

+ DiscoInfo discoInfo;

+ discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

+ discoInfo.addFeature(DiscoInfo::JingleFeature);

+ discoInfo.addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo.addFeature(DiscoInfo::Bytestream);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

+ client->getDiscoManager()->setCapsNode(CLIENT_NODE);

+ client->getDiscoManager()->setDiscoInfo(discoInfo);

+ client->getPresenceSender()->sendPresence(Presence::create());

+ SWIFT_LOG(debug) << "foo" << std::endl;

+ DefaultLocalJingleTransportCandidateGeneratorFactory *localFactory;

+ DefaultRemoteJingleTransportCandidateSelectorFactory *remoteFactory;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <Swiften/FileTransfer/OutgoingFileTransferManager.h>

+#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/Disco/EntityCapsManager.h>

+#include <Swiften/FileTransfer/DefaultLocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/DefaultRemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/StringCodecs/MD5.h>

+#include <Swiften/StringCodecs/SHA1.h>

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+ FileSender(const JID& jid, const std::string& password, const JID& recipient, const boost::filesystem::path& file) : jid(jid), password(password), recipient(recipient), file(file) {

+ tracer = new ClientXMLTracer(client);

+ client->getEntityCapsProvider()->onCapsChanged.connect(boost::bind(&FileSender::handleCapsChanged, this, _1));

+ delete tracer;

+

+

+ client->getFileTransferManager()->startListeningOnPort(19999);

+ //ByteArray fileData;

+ //readByteArrayFromFile(fileData, file.string());

+

+ // gather file information

+ /*StreamInitiationFileInfo fileInfo;

+

+ fileInfo.setName(file.filename());

+ fileInfo.setSize(boost::filesystem::file_size(file));

+ fileInfo.setDescription("Some file!");

+ fileInfo.setDate(boost::posix_time::from_time_t(boost::filesystem::last_write_time(file)));*/

+ //fileInfo.setHash(Hexify::hexify(MD5::getHash(fileData)));

+ /*

+ */

+ }

+

+ void handleCapsChanged(JID jid) {

+ if (jid.toBare() == recipient) {

+ // create ReadBytestream from file

+ boost::shared_ptr<FileReadBytestream> fileStream = boost::make_shared<FileReadBytestream>(file);

+

+ outgoingFileTransfer = client->getFileTransferManager()->createOutgoingFileTransfer(recipient, file, "Some File!", fileStream);

+

+ if (outgoingFileTransfer) {

+ std::cout << "started FT" << std::endl;

+ outgoingFileTransfer->start();

+ // TODO: getting notified about FT status and end

+ } else {

+ std::cout << "[ ERROR ] " << recipient << " doesn't support any kind of file transfer!" << std::endl;

+ //client->disconnect();

+ }

+ }

+

+ SOCKS5BytestreamRegistry* registry;

+ OutgoingFileTransfer::ref outgoingFileTransfer;

+ Swift::logging = true;

+ FileSender fileSender(sender, std::string(argv[2]), recipient, boost::filesystem::path(argv[4]));

+

+ onRead(result);

+ onWrite(bytes);

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "ConnectivityManager.h"

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Network/NetworkInterface.h>

+#include <Swiften/Network/PlatformNATTraversalGetPublicIPRequest.h>

+#include <Swiften/Network/PlatformNATTraversalRemovePortForwardingRequest.h>

+#include <Swiften/Network/PlatformNATTraversalWorker.h>

+#include <Swiften/Network/PlatformNetworkEnvironment.h>

+

+namespace Swift {

+

+ConnectivityManager::ConnectivityManager(PlatformNATTraversalWorker* worker) : natTraversalWorker(worker) {

+

+}

+

+ConnectivityManager::~ConnectivityManager() {

+ std::set<int> leftOpenPorts = ports;

+ foreach(int port, leftOpenPorts) {

+ removeListeningPort(port);

+ }

+}

+

+void ConnectivityManager::addListeningPort(int port) {

+ ports.insert(port);

+ boost::shared_ptr<PlatformNATTraversalGetPublicIPRequest> getIPRequest = natTraversalWorker->createGetPublicIPRequest();

+ if (getIPRequest) {

+ getIPRequest->onResult.connect(boost::bind(&ConnectivityManager::natTraversalGetPublicIPResult, this, _1));

+ getIPRequest->run();

+ }

+

+ boost::shared_ptr<PlatformNATTraversalForwardPortRequest> forwardPortRequest = natTraversalWorker->createForwardPortRequest(port, port);

+ if (forwardPortRequest) {

+ forwardPortRequest->onResult.connect(boost::bind(&ConnectivityManager::natTraversalForwardPortResult, this, _1));

+ forwardPortRequest->run();

+ }

+}

+

+void ConnectivityManager::removeListeningPort(int port) {

+ SWIFT_LOG(debug) << "remove listening port " << port << std::endl;

+ ports.erase(port);

+ boost::shared_ptr<PlatformNATTraversalRemovePortForwardingRequest> removePortForwardingRequest = natTraversalWorker->createRemovePortForwardingRequest(port, port);

+ if (removePortForwardingRequest) {

+ removePortForwardingRequest->run();

+ }

+}

+

+std::vector<HostAddressPort> ConnectivityManager::getHostAddressPorts() const {

+ PlatformNetworkEnvironment env;

+ std::vector<HostAddressPort> results;

+

+ std::vector<HostAddress> addresses;

+

+ foreach (NetworkInterface::ref iface, env.getNetworkInterfaces()) {

+ foreach (HostAddress address, iface->getAddresses()) {

+ foreach (int port, ports) {

+ results.push_back(HostAddressPort(address, port));

+ }

+ }

+ }

+

+ return results;

+}

+

+std::vector<HostAddressPort> ConnectivityManager::getAssistedHostAddressPorts() const {

+ std::vector<HostAddressPort> results;

+

+ if (publicAddress) {

+ foreach (int port, ports) {

+ results.push_back(HostAddressPort(publicAddress.get(), port));

+ }

+ }

+

+ return results;

+}

+

+void ConnectivityManager::natTraversalGetPublicIPResult(boost::optional<HostAddress> address) {

+ if (address) {

+ publicAddress = address;

+ SWIFT_LOG(debug) << "Public IP discovered as " << publicAddress.get().toString() << "." << std::endl;

+ } else {

+ SWIFT_LOG(debug) << "No public IP discoverable." << std::endl;

+ }

+}

+

+void ConnectivityManager::natTraversalForwardPortResult(boost::optional<PlatformNATTraversalForwardPortRequest::PortMapping> mapping) {

+ if (mapping) {

+ SWIFT_LOG(debug) << "Mapping port was successful." << std::endl;

+ } else {

+ SWIFT_LOG(debug) << "Mapping port has failed." << std::endl;

+ }

+}

+

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+#include <set>

+

+#include <boost/optional.hpp>

+

+#include <Swiften/Network/HostAddressPort.h>

+#include <Swiften/Network/PlatformNATTraversalForwardPortRequest.h>

+

+namespace Swift {

+

+class PlatformNATTraversalWorker;

+

+class ConnectivityManager {

+public:

+ ConnectivityManager(PlatformNATTraversalWorker*);

+ ~ConnectivityManager();

+public:

+ void addListeningPort(int port);

+ void removeListeningPort(int port);

+

+ std::vector<HostAddressPort> getHostAddressPorts() const;

+ std::vector<HostAddressPort> getAssistedHostAddressPorts() const;

+

+private:

+ void natTraversalGetPublicIPResult(boost::optional<HostAddress> address);

+ void natTraversalForwardPortResult(boost::optional<PlatformNATTraversalForwardPortRequest::PortMapping> mapping);

+

+private:

+ PlatformNATTraversalWorker* natTraversalWorker;

+

+ std::set<int> ports;

+ boost::optional<HostAddress> publicAddress;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "DefaultLocalJingleTransportCandidateGenerator.h"

+

+#include <vector>

+

+#include <boost/shared_ptr.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Elements/JingleIBBTransportPayload.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/FileTransfer/ConnectivityManager.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+

+namespace Swift {

+

+DefaultLocalJingleTransportCandidateGenerator::DefaultLocalJingleTransportCandidateGenerator(ConnectivityManager* connectivityManager, SOCKS5BytestreamRegistry* s5bRegistry, SOCKS5BytestreamProxy* s5bProxy, JID& ownJID) : connectivityManager(connectivityManager), s5bRegistry(s5bRegistry), s5bProxy(s5bProxy), ownJID(ownJID) {

+}

+

+DefaultLocalJingleTransportCandidateGenerator::~DefaultLocalJingleTransportCandidateGenerator() {

+}

+

+void DefaultLocalJingleTransportCandidateGenerator::generateLocalTransportCandidates(JingleTransportPayload::ref transportPayload) {

+ if (boost::dynamic_pointer_cast<JingleIBBTransportPayload>(transportPayload)) {

+ JingleTransportPayload::ref payL = boost::make_shared<JingleTransportPayload>();

+ payL->setSessionID(transportPayload->getSessionID());

+ onLocalTransportCandidatesGenerated(payL);

+ }

+ if (boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload)) {

+ JingleS5BTransportPayload::ref payL = boost::make_shared<JingleS5BTransportPayload>();

+ payL->setSessionID(transportPayload->getSessionID());

+ payL->setMode(JingleS5BTransportPayload::TCPMode);

+

+ const unsigned long localPreference = 0;

+

+ // get direct candidates

+ std::vector<HostAddressPort> directCandidates = connectivityManager->getHostAddressPorts();

+ foreach(HostAddressPort addressPort, directCandidates) {

+ JingleS5BTransportPayload::Candidate candidate;

+ candidate.type = JingleS5BTransportPayload::Candidate::DirectType;

+ candidate.jid = ownJID;

+ candidate.hostPort = addressPort;

+ candidate.priority = 65536 * 126 + localPreference;

+ candidate.cid = idGenerator.generateID();

+ payL->addCandidate(candidate);

+ }

+

+ // get assissted candidates

+ std::vector<HostAddressPort> assisstedCandidates = connectivityManager->getAssistedHostAddressPorts();

+ foreach(HostAddressPort addressPort, assisstedCandidates) {

+ JingleS5BTransportPayload::Candidate candidate;

+ candidate.type = JingleS5BTransportPayload::Candidate::AssistedType;

+ candidate.jid = ownJID;

+ candidate.hostPort = addressPort;

+ candidate.priority = 65536 * 120 + localPreference;

+ candidate.cid = idGenerator.generateID();

+ payL->addCandidate(candidate);

+ }

+

+ // get proxy candidates

+ std::vector<S5BProxyRequest::ref> proxyCandidates = s5bProxy->getS5BProxies();

+ foreach(S5BProxyRequest::ref proxy, proxyCandidates) {

+ JingleS5BTransportPayload::Candidate candidate;

+ candidate.type = JingleS5BTransportPayload::Candidate::ProxyType;

+ candidate.jid = proxy->getStreamHost().get().jid;

+ candidate.hostPort = proxy->getStreamHost().get().addressPort;

+ candidate.priority = 65536 * 10 + localPreference;

+ candidate.cid = idGenerator.generateID();

+ payL->addCandidate(candidate);

+ }

+

+ onLocalTransportCandidatesGenerated(payL);

+ }

+

+}

+

+bool DefaultLocalJingleTransportCandidateGenerator::isActualCandidate(JingleTransportPayload::ref transportPayload) {

+ if (!transportPayload.get()) return false;

+ return false;

+}

+

+int DefaultLocalJingleTransportCandidateGenerator::getPriority(JingleTransportPayload::ref /* transportPayload */) {

+ return 0;

+}

+

+JingleTransport::ref DefaultLocalJingleTransportCandidateGenerator::selectTransport(JingleTransportPayload::ref /* transportPayload */) {

+ return JingleTransport::ref();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>

+

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+

+class SOCKS5BytestreamRegistry;

+class SOCKS5BytestreamProxy;

+class ConnectivityManager;

+

+class DefaultLocalJingleTransportCandidateGenerator : public LocalJingleTransportCandidateGenerator {

+public:

+ DefaultLocalJingleTransportCandidateGenerator(ConnectivityManager* connectivityManager, SOCKS5BytestreamRegistry* s5bRegistry, SOCKS5BytestreamProxy* s5bProxy, JID& ownJID);

+ virtual ~DefaultLocalJingleTransportCandidateGenerator();

+

+ virtual void generateLocalTransportCandidates(JingleTransportPayload::ref);

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref);

+ virtual int getPriority(JingleTransportPayload::ref);

+ virtual JingleTransport::ref selectTransport(JingleTransportPayload::ref);

+

+private:

+ IDGenerator idGenerator;

+ ConnectivityManager* connectivityManager;

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamProxy* s5bProxy;

+ JID ownJID;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "DefaultLocalJingleTransportCandidateGeneratorFactory.h"

+

+#include <Swiften/FileTransfer/DefaultLocalJingleTransportCandidateGenerator.h>

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+DefaultLocalJingleTransportCandidateGeneratorFactory::DefaultLocalJingleTransportCandidateGeneratorFactory(ConnectivityManager* connectivityManager, SOCKS5BytestreamRegistry* s5bRegistry, SOCKS5BytestreamProxy* s5bProxy, const JID& ownJID) : connectivityManager(connectivityManager), s5bRegistry(s5bRegistry), s5bProxy(s5bProxy), ownJID(ownJID) {

+}

+

+DefaultLocalJingleTransportCandidateGeneratorFactory::~DefaultLocalJingleTransportCandidateGeneratorFactory() {

+}

+

+LocalJingleTransportCandidateGenerator* DefaultLocalJingleTransportCandidateGeneratorFactory::createCandidateGenerator() {

+ return new DefaultLocalJingleTransportCandidateGenerator(connectivityManager, s5bRegistry, s5bProxy, ownJID);

+}

+

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGeneratorFactory.h>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+

+class ConnectivityManager;

+class SOCKS5BytestreamRegistry;

+class SOCKS5BytestreamProxy;

+

+class DefaultLocalJingleTransportCandidateGeneratorFactory : public LocalJingleTransportCandidateGeneratorFactory{

+public:

+ DefaultLocalJingleTransportCandidateGeneratorFactory(ConnectivityManager* connectivityManager, SOCKS5BytestreamRegistry* s5bRegistry, SOCKS5BytestreamProxy* s5bProxy, const JID& ownJID);

+ virtual ~DefaultLocalJingleTransportCandidateGeneratorFactory();

+

+ LocalJingleTransportCandidateGenerator* createCandidateGenerator();

+

+private:

+ ConnectivityManager* connectivityManager;

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamProxy* s5bProxy;

+ JID ownJID;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "DefaultRemoteJingleTransportCandidateSelector.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/Network/ConnectionFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+

+namespace Swift {

+

+DefaultRemoteJingleTransportCandidateSelector::DefaultRemoteJingleTransportCandidateSelector(ConnectionFactory* connectionFactory, TimerFactory* timerFactory) : connectionFactory(connectionFactory), timerFactory(timerFactory) {

+}

+

+DefaultRemoteJingleTransportCandidateSelector::~DefaultRemoteJingleTransportCandidateSelector() {

+}

+

+void DefaultRemoteJingleTransportCandidateSelector::addRemoteTransportCandidates(JingleTransportPayload::ref transportPayload) {

+ JingleS5BTransportPayload::ref s5bPayload;

+ transportSID = transportPayload->getSessionID();

+ if ((s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload))) {

+ foreach(JingleS5BTransportPayload::Candidate c, s5bPayload->getCandidates()) {

+ candidates.push(c);

+ }

+ }

+}

+

+void DefaultRemoteJingleTransportCandidateSelector::selectCandidate() {

+ tryNextCandidate(true);

+}

+

+void DefaultRemoteJingleTransportCandidateSelector::tryNextCandidate(bool error) {

+ if (error) {

+ if (s5bSession) {

+ SWIFT_LOG(debug) << "failed to connect" << std::endl;

+ }

+ if (candidates.empty()) {

+ // failed to connect to any of the candidates

+ // issue an error

+ SWIFT_LOG(debug) << "out of candidates )=" << std::endl;

+ JingleS5BTransportPayload::ref failed = boost::make_shared<JingleS5BTransportPayload>();

+ failed->setCandidateError(true);

+ failed->setSessionID(transportSID);

+ onRemoteTransportCandidateSelectFinished(failed);

+ } else {

+ lastCandidate = candidates.top();

+ // only try direct or assisted for now

+ if (lastCandidate.type == JingleS5BTransportPayload::Candidate::DirectType ||

+ lastCandidate.type == JingleS5BTransportPayload::Candidate::AssistedType || lastCandidate.type == JingleS5BTransportPayload::Candidate::ProxyType ) {

+ // create connection

+ connection = connectionFactory->createConnection();

+ s5bSession = boost::make_shared<SOCKS5BytestreamClientSession>(connection, lastCandidate.hostPort, SOCKS5BytestreamRegistry::getHostname(transportSID, requester, target), timerFactory);

+

+ // bind onReady to this method

+ s5bSession->onSessionReady.connect(boost::bind(&DefaultRemoteJingleTransportCandidateSelector::tryNextCandidate, this, _1));

+

+ std::string candidateType;

+ if (lastCandidate.type == JingleS5BTransportPayload::Candidate::DirectType) {

+ candidateType = "direct";

+ } else if (lastCandidate.type == JingleS5BTransportPayload::Candidate::AssistedType) {

+ candidateType = "assisted";

+ } else if (lastCandidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ candidateType = "proxy";

+ }

+

+ // initiate connect

+ SWIFT_LOG(debug) << "try to connect to candidate of type " << candidateType << " : " << lastCandidate.hostPort.toString() << std::endl;

+ s5bSession->start();

+

+ // that's it. we're gonna be called back

+ candidates.pop();

+ } else {

+ s5bSession.reset();

+ candidates.pop();

+ tryNextCandidate(true);

+ }

+ }

+ } else {

+ // we have a working connection, hooray

+ JingleS5BTransportPayload::ref success = boost::make_shared<JingleS5BTransportPayload>();

+ success->setCandidateUsed(lastCandidate.cid);

+ success->setSessionID(transportSID);

+ onRemoteTransportCandidateSelectFinished(success);

+ }

+}

+

+void DefaultRemoteJingleTransportCandidateSelector::setMinimumPriority(int priority) {

+ SWIFT_LOG(debug) << "priority: " << priority << std::endl;

+}

+

+void DefaultRemoteJingleTransportCandidateSelector::setRequesterTargtet(const JID& requester, const JID& target) {

+ this->requester = requester;

+ this->target = target;

+}

+

+SOCKS5BytestreamClientSession::ref DefaultRemoteJingleTransportCandidateSelector::getS5BSession() {

+ return s5bSession;

+}

+

+bool DefaultRemoteJingleTransportCandidateSelector::isActualCandidate(JingleTransportPayload::ref /* transportPayload */) {

+ return false;

+}

+

+int DefaultRemoteJingleTransportCandidateSelector::getPriority(JingleTransportPayload::ref /* transportPayload */) {

+ return 0;

+}

+

+JingleTransport::ref DefaultRemoteJingleTransportCandidateSelector::selectTransport(JingleTransportPayload::ref /* transportPayload */) {

+ return JingleTransport::ref();

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <queue>

+#include <vector>

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/JID/JID.h>

+#include <Swiften/Network/Connection.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+

+

+namespace Swift {

+

+class ConnectionFactory;

+class TimerFactory;

+

+class DefaultRemoteJingleTransportCandidateSelector : public RemoteJingleTransportCandidateSelector {

+public:

+ DefaultRemoteJingleTransportCandidateSelector(ConnectionFactory*, TimerFactory*);

+ virtual ~DefaultRemoteJingleTransportCandidateSelector();

+

+ virtual void addRemoteTransportCandidates(JingleTransportPayload::ref);

+ virtual void selectCandidate();

+ virtual void setMinimumPriority(int);

+ void setRequesterTargtet(const JID& requester, const JID& target);

+ virtual SOCKS5BytestreamClientSession::ref getS5BSession();

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref);

+ virtual int getPriority(JingleTransportPayload::ref);

+ virtual JingleTransport::ref selectTransport(JingleTransportPayload::ref);

+

+private:

+ void tryNextCandidate(bool error);

+

+private:

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+

+ std::priority_queue<JingleS5BTransportPayload::Candidate, std::vector<JingleS5BTransportPayload::Candidate>, JingleS5BTransportPayload::CompareCandidate> candidates;

+

+ std::string transportSID;

+ boost::shared_ptr<Connection> connection;

+ boost::shared_ptr<SOCKS5BytestreamClientSession> s5bSession;

+ JingleS5BTransportPayload::Candidate lastCandidate;

+ JID requester;

+ JID target;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "DefaultRemoteJingleTransportCandidateSelectorFactory.h"

+

+#include <Swiften/FileTransfer/DefaultRemoteJingleTransportCandidateSelector.h>

+

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+DefaultRemoteJingleTransportCandidateSelectorFactory::DefaultRemoteJingleTransportCandidateSelectorFactory(ConnectionFactory* connectionFactory, TimerFactory* timerFactory) : connectionFactory(connectionFactory), timerFactory(timerFactory) {

+}

+

+DefaultRemoteJingleTransportCandidateSelectorFactory::~DefaultRemoteJingleTransportCandidateSelectorFactory() {

+}

+

+RemoteJingleTransportCandidateSelector* DefaultRemoteJingleTransportCandidateSelectorFactory::createCandidateSelector() {

+ return new DefaultRemoteJingleTransportCandidateSelector(connectionFactory, timerFactory);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelectorFactory.h>

+

+namespace Swift {

+

+class ConnectionFactory;

+class TimerFactory;

+

+class DefaultRemoteJingleTransportCandidateSelectorFactory : public RemoteJingleTransportCandidateSelectorFactory {

+public:

+ DefaultRemoteJingleTransportCandidateSelectorFactory(ConnectionFactory*, TimerFactory*);

+ virtual ~DefaultRemoteJingleTransportCandidateSelectorFactory();

+

+ RemoteJingleTransportCandidateSelector* createCandidateSelector();

+

+private:

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+};

+

+}

+ onRead(result);

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/FileTransfer/FileTransferError.h>

+

+namespace Swift {

+

+class FileTransfer {

+public:

+ struct State {

+ enum FTState {

+ Canceled,

+ Failed,

+ Finished,

+ Negotiating,

+ Transferring,

+ WaitingForStart,

+ WaitingForAccept,

+ };

+

+ FTState state;

+ std::string message;

+

+ State(FTState state) : state(state), message("") {}

+ State(FTState state, std::string message) : state(state), message(message) {}

+ };

+

+public:

+ typedef boost::shared_ptr<FileTransfer> ref;

+

+public:

+ uintmax_t fileSizeInBytes;

+ std::string filename;

+ std::string algo;

+ std::string hash;

+

+public:

+ virtual void cancel() = 0;

+

+public:

+ boost::signal<void (int /* proccessedBytes */)> onProcessedBytes;

+ boost::signal<void (State)> onStateChange;

+ boost::signal<void (boost::optional<FileTransferError>)> onFinished;

+

+public:

+ virtual ~FileTransfer() {}

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swiften/FileTransfer/FileTransferManager.h>

+

+namespace Swift {

+

+FileTransferManager::~FileTransferManager() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <boost/filesystem.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

+#include <Swiften/FileTransfer/IncomingFileTransfer.h>

+

+namespace Swift {

+ class ReadBytestream;

+ class S5BProxyRequest;

+

+ class FileTransferManager {

+ public:

+ virtual ~FileTransferManager();

+

+ virtual void startListeningOnPort(int port) = 0;

+ virtual void addS5BProxy(boost::shared_ptr<S5BProxyRequest> proxy) = 0;

+

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID& to, const boost::filesystem::path& filepath, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream) = 0;

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID& to, const std::string& filename, const std::string& description, const boost::uintmax_t sizeInBytes, const boost::posix_time::ptime& lastModified, boost::shared_ptr<ReadBytestream> bytestream) = 0;

+

+ boost::signal<void (IncomingFileTransfer::ref)> onIncomingFileTransfer;

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swiften/FileTransfer/FileTransferManagerImpl.h>

+

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/foreach.h>

+#include "Swiften/Disco/EntityCapsProvider.h"

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/StreamInitiationFileInfo.h>

+#include <Swiften/FileTransfer/ConnectivityManager.h>

+#include <Swiften/FileTransfer/OutgoingFileTransferManager.h>

+#include <Swiften/FileTransfer/IncomingFileTransferManager.h>

+#include <Swiften/FileTransfer/DefaultLocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/DefaultRemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Network/ConnectionFactory.h>

+#include <Swiften/Network/ConnectionServerFactory.h>

+#include <Swiften/Network/HostAddress.h>

+#include <Swiften/Network/PlatformNATTraversalWorker.h>

+

+namespace Swift {

+

+FileTransferManagerImpl::FileTransferManagerImpl(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, PresenceOracle* presOracle, ConnectionFactory* connectionFactory, ConnectionServerFactory* connectionServerFactory, TimerFactory* timerFactory, PlatformNATTraversalWorker* natTraversalWorker) : ownJID(ownFullJID), jingleSM(jingleSessionManager), iqRouter(router), capsProvider(capsProvider), presenceOracle(presOracle), timerFactory(timerFactory), connectionFactory(connectionFactory), connectionServerFactory(connectionServerFactory), natTraversalWorker(natTraversalWorker), bytestreamServer(NULL) {

+ assert(!ownFullJID.isBare());

+

+ connectivityManager = new ConnectivityManager(natTraversalWorker);

+ bytestreamRegistry = new SOCKS5BytestreamRegistry();

+ bytestreamProxy = new SOCKS5BytestreamProxy(connectionFactory, timerFactory);

+

+ localCandidateGeneratorFactory = new DefaultLocalJingleTransportCandidateGeneratorFactory(connectivityManager, bytestreamRegistry, bytestreamProxy, ownFullJID);

+ remoteCandidateSelectorFactory = new DefaultRemoteJingleTransportCandidateSelectorFactory(connectionFactory, timerFactory);

+ outgoingFTManager = new OutgoingFileTransferManager(ownJID, jingleSM, iqRouter, capsProvider, remoteCandidateSelectorFactory, localCandidateGeneratorFactory, bytestreamRegistry, bytestreamProxy);

+ incomingFTManager = new IncomingFileTransferManager(ownJID, jingleSM, iqRouter, remoteCandidateSelectorFactory, localCandidateGeneratorFactory, bytestreamRegistry, bytestreamProxy, timerFactory);

+ incomingFTManager->onIncomingFileTransfer.connect(onIncomingFileTransfer);

+}

+

+FileTransferManagerImpl::~FileTransferManagerImpl() {

+ if (bytestreamServer) {

+ bytestreamServer->stop();

+ }

+ delete incomingFTManager;

+ delete outgoingFTManager;

+ delete remoteCandidateSelectorFactory;

+ delete localCandidateGeneratorFactory;

+ delete connectivityManager;

+}

+

+void FileTransferManagerImpl::startListeningOnPort(int port) {

+ // TODO: create a server for each interface we're on

+ SWIFT_LOG(debug) << "Start listening on port " << port << " and hope it's not in use." << std::endl;

+ boost::shared_ptr<ConnectionServer> server = connectionServerFactory->createConnectionServer(HostAddress("0.0.0.0"), port);

+ server->start();

+ bytestreamServer = new SOCKS5BytestreamServer(server, bytestreamRegistry);

+ bytestreamServer->start();

+ connectivityManager->addListeningPort(port);

+}

+

+void FileTransferManagerImpl::addS5BProxy(S5BProxyRequest::ref proxy) {

+ bytestreamProxy->addS5BProxy(proxy);

+}

+

+boost::optional<JID> FileTransferManagerImpl::highestPriorityJIDSupportingFileTransfer(const JID& bareJID) {

+ JID fullReceipientJID;

+ int priority = INT_MIN;

+

+ //getAllPresence(bareJID) gives you all presences for the bare JID (i.e. all resources) Remko Tronçon @ 11:11

+ std::vector<Presence::ref> presences = presenceOracle->getAllPresence(bareJID);

+

+ //iterate over them

+ foreach(Presence::ref pres, presences) {

+ if (pres->getPriority() > priority) {

+ // look up caps from the jid

+ DiscoInfo::ref info = capsProvider->getCaps(pres->getFrom());

+ if (info && info->hasFeature(DiscoInfo::JingleFeature) && info->hasFeature(DiscoInfo::JingleFTFeature) &&

+ info->hasFeature(DiscoInfo::JingleTransportsIBBFeature)) {

+

+ priority = pres->getPriority();

+ fullReceipientJID = pres->getFrom();

+ }

+ }

+ }

+

+ return fullReceipientJID.isValid() ? boost::optional<JID>(fullReceipientJID) : boost::optional<JID>();

+}

+

+OutgoingFileTransfer::ref FileTransferManagerImpl::createOutgoingFileTransfer(const JID& to, const boost::filesystem::path& filepath, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream) {

+ std::string filename = filepath.filename();

+ uintmax_t sizeInBytes = boost::filesystem::file_size(filepath);

+ boost::posix_time::ptime lastModified = boost::posix_time::from_time_t(boost::filesystem::last_write_time(filepath));

+ return createOutgoingFileTransfer(to, filename, description, sizeInBytes, lastModified, bytestream);

+}

+

+OutgoingFileTransfer::ref FileTransferManagerImpl::createOutgoingFileTransfer(const JID& to, const std::string& filename, const std::string& description, const uintmax_t sizeInBytes, const boost::posix_time::ptime& lastModified, boost::shared_ptr<ReadBytestream> bytestream) {

+ StreamInitiationFileInfo fileInfo;

+ fileInfo.setDate(lastModified);

+ fileInfo.setSize(sizeInBytes);

+ fileInfo.setName(filename);

+ fileInfo.setDescription(description);

+

+ JID receipient = to;

+

+ if(receipient.isBare()) {

+ boost::optional<JID> fullJID = highestPriorityJIDSupportingFileTransfer(receipient);

+ if (fullJID.is_initialized()) {

+ receipient = fullJID.get();

+ } else {

+ return OutgoingFileTransfer::ref();

+ }

+ }

+

+ return outgoingFTManager->createOutgoingFileTransfer(receipient, bytestream, fileInfo);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+#include <string>

+

+#include <boost/filesystem.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <boost/optional.hpp>

+

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

+#include <Swiften/FileTransfer/IncomingFileTransfer.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+

+namespace Swift {

+

+class Client;

+class ConnectionFactory;

+class ConnectionServerFactory;

+class ConnectivityManager;

+class EntityCapsProvider;

+class IQRouter;

+class IncomingFileTransferManager;

+class JingleSessionManager;

+class LocalJingleTransportCandidateGeneratorFactory;

+class OutgoingFileTransferManager;

+class PlatformNATTraversalWorker;

+class PresenceOracle;

+class ReadBytestream;

+class RemoteJingleTransportCandidateSelectorFactory;

+class SOCKS5BytestreamRegistry;

+class SOCKS5BytestreamServer;

+class SOCKS5BytestreamProxy;

+class TimerFactory;

+

+class FileTransferManagerImpl : public FileTransferManager {

+public:

+ FileTransferManagerImpl(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, PresenceOracle* presOracle, ConnectionFactory* connectionFactory, ConnectionServerFactory* connectionServerFactory, TimerFactory* timerFactory, PlatformNATTraversalWorker* natTraversalWorker);

+ ~FileTransferManagerImpl();

+

+ void startListeningOnPort(int port);

+ void addS5BProxy(S5BProxyRequest::ref proxy);

+

+ OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID& to, const boost::filesystem::path& filepath, const std::string& description, boost::shared_ptr<ReadBytestream> bytestream);

+ OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID& to, const std::string& filename, const std::string& description, const boost::uintmax_t sizeInBytes, const boost::posix_time::ptime& lastModified, boost::shared_ptr<ReadBytestream> bytestream);

+

+ private:

+ boost::optional<JID> highestPriorityJIDSupportingFileTransfer(const JID& bareJID);

+

+private:

+ JID ownJID;

+

+ OutgoingFileTransferManager* outgoingFTManager;

+ IncomingFileTransferManager* incomingFTManager;

+ RemoteJingleTransportCandidateSelectorFactory* remoteCandidateSelectorFactory;

+ LocalJingleTransportCandidateGeneratorFactory* localCandidateGeneratorFactory;

+ JingleSessionManager* jingleSM;

+ IQRouter* iqRouter;

+ EntityCapsProvider* capsProvider;

+ PresenceOracle* presenceOracle;

+

+ TimerFactory* timerFactory;

+ ConnectionFactory* connectionFactory;

+ ConnectionServerFactory* connectionServerFactory;

+ PlatformNATTraversalWorker* natTraversalWorker;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+ SOCKS5BytestreamServer* bytestreamServer;

+ SOCKS5BytestreamProxy* bytestreamProxy;

+ ConnectivityManager* connectivityManager;

+};

+

+}

+ onWrite(data);

+}

+

+void FileWriteBytestream::close() {

+ if (stream) {

+ stream->close();

+ stream = NULL;

+ }

+ void close();

+#include <cassert>

+

+ SWIFT_LOG(debug) << "IBB open received" << std::endl;

+ SWIFT_LOG(debug) << "IBB close received" << std::endl;

+ SWIFT_LOG(debug) << "wrong from/sessionID: " << from << " == " << session->from << " / " <<ibb->getStreamID() << " == " << session->id << std::endl;

+ assert(!id.empty());

+ assert(from.isValid());

+ SWIFT_LOG(debug) << "receive session started" << std::endl;

+ SWIFT_LOG(debug) << "receive session stopped" << std::endl;

+ if (!error && active) {

+ onBytesSent(data.size());

+ boost::signal<void (int)> onBytesSent;

+#include <Swiften/JID/JID.h>

+#include <Swiften/FileTransfer/FileTransfer.h>

+ class IncomingFileTransfer : public FileTransfer {

+ virtual const JID& getSender() const = 0;

+IncomingFileTransferManager::IncomingFileTransferManager(const JID& ourFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router,

+ RemoteJingleTransportCandidateSelectorFactory* remoteFactory,

+ LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy, TimerFactory* timerFactory) : ourJID(ourFullJID), jingleSessionManager(jingleSessionManager), router(router), remoteFactory(remoteFactory), localFactory(localFactory), bytestreamRegistry(bytestreamRegistry), bytestreamProxy(bytestreamProxy), timerFactory(timerFactory) {

+

+ JingleFileTransferDescription::ref description = content->getDescription<JingleFileTransferDescription>();

+

+ if (description && description->getOffers().size() == 1) {

+ IncomingJingleFileTransfer::ref transfer = boost::make_shared<IncomingJingleFileTransfer>(ourJID, session, content, remoteFactory, localFactory, router, bytestreamRegistry, bytestreamProxy, timerFactory);

+ onIncomingFileTransfer(transfer);

+ } else {

+ std::cerr << "Received a file-transfer request with no description or more than one file!" << std::endl;

+ session->sendTerminate(JinglePayload::Reason::FailedApplication);

+ }

+ session->sendTerminate(JinglePayload::Reason::UnsupportedTransports);

+ class SOCKS5BytestreamRegistry;

+ class SOCKS5BytestreamProxy;

+ class TimerFactory;

+ IncomingFileTransferManager(const JID& ourFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router, RemoteJingleTransportCandidateSelectorFactory* remoteFactory, LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy, TimerFactory* timerFactory);

+ JID ourJID;

+ RemoteJingleTransportCandidateSelectorFactory* remoteFactory;

+ LocalJingleTransportCandidateGeneratorFactory* localFactory;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+ SOCKS5BytestreamProxy* bytestreamProxy;

+ TimerFactory* timerFactory;

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Elements/JingleFileTransferHash.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/FileTransfer/IncrementalBytestreamHashCalculator.h>

+#include <Swiften/FileTransfer/JingleIncomingIBBTransport.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+#include <Swiften/Network/TimerFactory.h>

+#include <Swiften/Queries/GenericRequest.h>

+ const JID& ourJID,

+ IQRouter* router,

+ SOCKS5BytestreamRegistry* registry,

+ SOCKS5BytestreamProxy* proxy,

+ TimerFactory* timerFactory) :

+ ourJID(ourJID),

+ timerFactory(timerFactory),

+ receivedBytes(0),

+ s5bRegistry(registry),

+ s5bProxy(proxy),

+ localTransportCandidateSelectFinished(false),

+ serverSession(0) {

+ session->onSessionTerminateReceived.connect(boost::bind(&IncomingJingleFileTransfer::handleSessionTerminateReceived, this, _1));

+ session->onSessionInfoReceived.connect(boost::bind(&IncomingJingleFileTransfer::handleSessionInfoReceived, this, _1));

+ assert(description->getOffers().size() == 1);

+ StreamInitiationFileInfo fileInfo = description->getOffers().front();

+ fileSizeInBytes = fileInfo.getSize();

+ filename = fileInfo.getName();

+ hash = fileInfo.getHash();

+ algo = fileInfo.getAlgo();

+

+ waitOnHashTimer = timerFactory->createTimer(5000);

+ waitOnHashTimer->onTick.connect(boost::bind(&IncomingJingleFileTransfer::finishOffTransfer, this));

+ stream->onWrite.disconnect(boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+ delete hashCalculator;

+

+ assert(!this->stream);

+ hashCalculator = new IncrementalBytestreamHashCalculator( algo == "md5" || hash.empty() , algo == "sha-1" || hash.empty() );

+ stream->onWrite.connect(boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+ stream->onWrite.connect(boost::bind(&IncomingJingleFileTransfer::handleWriteStreamDataReceived, this, _1));

+ onStateChange(FileTransfer::State(FileTransfer::State::Negotiating));

+ SWIFT_LOG(debug) << "Got IBB transport payload!" << std::endl;

+ session->sendAccept(getContentID(), initialContent->getDescriptions()[0], ibbTransport);

+ SWIFT_LOG(debug) << "Got S5B transport payload!" << std::endl;

+ s5bSessionID = s5bTransport->getSessionID().empty() ? idGenerator.generateID() : s5bTransport->getSessionID();

+ s5bDestination = SOCKS5BytestreamRegistry::getHostname(s5bSessionID, ourJID, session->getInitiator());

+ s5bRegistry->addWriteBytestream(s5bDestination, stream);

+ fillCandidateMap(theirCandidates, s5bTransport);

+ candidateSelector->setRequesterTargtet(session->getInitiator(), ourJID);

+ s5bTransport->setSessionID(s5bSessionID);

+ candidateGenerator->generateLocalTransportCandidates(s5bTransport);

+const JID& IncomingJingleFileTransfer::getSender() const {

+ return session->getInitiator();

+}

+

+void IncomingJingleFileTransfer::cancel() {

+ session->sendTerminate(JinglePayload::Reason::Cancel);

+

+ if (activeTransport) activeTransport->stop();

+ if (serverSession) serverSession->stop();

+ if (clientSession) clientSession->stop();

+ onStateChange(FileTransfer::State(FileTransfer::State::Canceled));

+}

+ if (JingleS5BTransportPayload::ref s5bCandidates = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(candidates)) {

+ //localTransportCandidateSelectFinished = true;

+ //JingleS5BTransportPayload::ref emptyCandidates = boost::make_shared<JingleS5BTransportPayload>();

+ //emptyCandidates->setSessionID(s5bCandidates->getSessionID());

+ fillCandidateMap(ourCandidates, s5bCandidates);

+ session->sendAccept(getContentID(), initialContent->getDescriptions()[0], s5bCandidates);

+

+ state = NegotiatingTransport;

+ candidateSelector->selectCandidate();

+ }

+ else {

+ SWIFT_LOG(debug) << "Unhandled state!" << std::endl;

+ SWIFT_LOG(debug) << std::endl;

+ if (state == Terminated) {

+ return;

+ }

+ if (JingleS5BTransportPayload::ref s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transport)) {

+ //remoteTransportCandidateSelectFinished = true;

+ //selectedRemoteTransportCandidate = transport;

+ ourCandidate = s5bPayload;

+ //checkCandidateSelected();

+ decideOnUsedTransport();

+ session->sendTransportInfo(getContentID(), s5bPayload);

+ }

+ else {

+ SWIFT_LOG(debug) << "Expected something different here." << std::endl;

+ }

+ assert(false);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ activeTransport->onFinished.connect(boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+bool IncomingJingleFileTransfer::verifyReceviedData() {

+ if (algo.empty() || hash.empty()) {

+ SWIFT_LOG(debug) << "no verification possible, skipping" << std::endl;

+ return true;

+ } else {

+ if (algo == "sha-1") {

+ SWIFT_LOG(debug) << "verify data via SHA-1 hash: " << (hash == hashCalculator->getSHA1String()) << std::endl;

+ return hash == hashCalculator->getSHA1String();

+ }

+ else if (algo == "md5") {

+ SWIFT_LOG(debug) << "verify data via MD5 hash: " << (hash == hashCalculator->getMD5String()) << std::endl;

+ return hash == hashCalculator->getMD5String();

+ }

+ else {

+ SWIFT_LOG(debug) << "no verification possible, skipping" << std::endl;

+ return true;

+ }

+ }

+}

+

+void IncomingJingleFileTransfer::finishOffTransfer() {

+ if (verifyReceviedData()) {

+ onStateChange(FileTransfer::State(FileTransfer::State::Finished));

+ session->sendTerminate(JinglePayload::Reason::Success);

+ } else {

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed, "Verification failed."));

+ session->sendTerminate(JinglePayload::Reason::MediaError);

+ }

+ state = Terminated;

+ waitOnHashTimer->stop();

+}

+

+void IncomingJingleFileTransfer::handleSessionInfoReceived(JinglePayload::ref jinglePayload) {

+ if (state == Terminated) {

+ return;

+ }

+ JingleFileTransferHash::ref transferHash = jinglePayload->getPayload<JingleFileTransferHash>();

+ if (transferHash) {

+ SWIFT_LOG(debug) << "Recevied hash information." << std::endl;

+ if (transferHash->getHashes().find("sha-1") != transferHash->getHashes().end()) {

+ algo = "sha-1";

+ hash = transferHash->getHashes().at("sha-1");

+ }

+ else if (transferHash->getHashes().find("md5") != transferHash->getHashes().end()) {

+ algo = "md5";

+ hash = transferHash->getHashes().at("md5");

+ }

+ checkIfAllDataReceived();

+ }

+}

+

+void IncomingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

+ SWIFT_LOG(debug) << "session terminate received" << std::endl;

+ if (activeTransport) activeTransport->stop();

+ if (reason && reason.get().type == JinglePayload::Reason::Cancel) {

+ onStateChange(FileTransfer::State(FileTransfer::State::Canceled, "Other user canceled the transfer."));

+ }

+ else if (reason && reason.get().type == JinglePayload::Reason::Success) {

+ /*if (verifyReceviedData()) {

+ onStateChange(FileTransfer::State(FileTransfer::State::Finished));

+ } else {

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed, "Verification failed."));

+ }*/

+ }

+void IncomingJingleFileTransfer::checkIfAllDataReceived() {

+ if (receivedBytes == fileSizeInBytes) {

+ SWIFT_LOG(debug) << "All data received." << std::endl;

+ if (hash.empty()) {

+ SWIFT_LOG(debug) << "No hash information yet. Waiting 5 seconds on hash info." << std::endl;

+ waitOnHashTimer->start();

+ } else {

+ SWIFT_LOG(debug) << "We already have hash info using " << algo << " algorithm. Finishing off transfer." << std::endl;

+ finishOffTransfer();

+ }

+ }

+ else if (receivedBytes > fileSizeInBytes) {

+ SWIFT_LOG(debug) << "We got more than we could handle!" << std::endl;

+ }

+}

+

+ SWIFT_LOG(debug) << data.size() << " bytes received" << std::endl;

+ onProcessedBytes(data.size());

+ receivedBytes += data.size();

+ checkIfAllDataReceived();

+}

+

+void IncomingJingleFileTransfer::handleWriteStreamDataReceived(const std::vector<unsigned char>& data) {

+ receivedBytes += data.size();

+ checkIfAllDataReceived();

+}

+

+void IncomingJingleFileTransfer::useOurCandidateChoiceForTransfer(JingleS5BTransportPayload::Candidate candidate) {

+ SWIFT_LOG(debug) << std::endl;

+ if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ // get proxy client session from remoteCandidateSelector

+ clientSession = candidateSelector->getS5BSession();

+

+ // wait on <activated/> transport-info

+ } else {

+ // ask s5b client

+ clientSession = candidateSelector->getS5BSession();

+ if (clientSession) {

+ state = Transferring;

+ SWIFT_LOG(debug) << clientSession->getAddressPort().toString() << std::endl;

+ clientSession->onBytesReceived.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startReceiving(stream);

+ } else {

+ SWIFT_LOG(debug) << "No S5B client session found!!!" << std::endl;

+ }

+ }

+void IncomingJingleFileTransfer::useTheirCandidateChoiceForTransfer(JingleS5BTransportPayload::Candidate candidate) {

+ SWIFT_LOG(debug) << std::endl;

+

+ if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ // get proxy client session from s5bRegistry

+ clientSession = s5bProxy->createSOCKS5BytestreamClientSession(candidate.hostPort, SOCKS5BytestreamRegistry::getHostname(s5bSessionID, ourJID, session->getInitiator()));

+ clientSession->onSessionReady.connect(boost::bind(&IncomingJingleFileTransfer::proxySessionReady, this, candidate.jid, _1));

+ clientSession->start();

+

+ // on reply send activate

+ } else {

+ // ask s5b server

+ serverSession = s5bRegistry->getConnectedSession(s5bDestination);

+ if (serverSession) {

+ state = Transferring;

+ serverSession->onBytesReceived.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ serverSession->onFinished.connect(boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+ serverSession->startTransfer();

+ } else {

+ SWIFT_LOG(debug) << "No S5B server session found!!!" << std::endl;

+ }

+ }

+}

+

+void IncomingJingleFileTransfer::fillCandidateMap(CandidateMap& map, JingleS5BTransportPayload::ref s5bPayload) {

+ map.clear();

+ foreach (JingleS5BTransportPayload::Candidate candidate, s5bPayload->getCandidates()) {

+ map[candidate.cid] = candidate;

+ }

+}

+

+

+void IncomingJingleFileTransfer::decideOnUsedTransport() {

+ if (ourCandidate && theirCandidate) {

+ if (ourCandidate->hasCandidateError() && theirCandidate->hasCandidateError()) {

+ state = WaitingForFallbackOrTerminate;

+ return;

+ }

+ std::string our_cid = ourCandidate->getCandidateUsed();

+ std::string their_cid = theirCandidate->getCandidateUsed();

+ if (ourCandidate->hasCandidateError() && !their_cid.empty()) {

+ useTheirCandidateChoiceForTransfer(ourCandidates[their_cid]);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+ else if (theirCandidate->hasCandidateError() && !our_cid.empty()) {

+ useOurCandidateChoiceForTransfer(theirCandidates[our_cid]);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+ else if (!our_cid.empty() && !their_cid.empty()) {

+ // compare priorites, if same they win

+ if (ourCandidates.find(their_cid) == ourCandidates.end() || theirCandidates.find(our_cid) == theirCandidates.end()) {

+ SWIFT_LOG(debug) << "Didn't recognize candidate IDs!" << std::endl;

+ session->sendTerminate(JinglePayload::Reason::FailedTransport);

+ onStateChange(FileTransfer::State(FileTransfer::State::Canceled, "Failed to negotiate candidate."));

+ onFinished(FileTransferError(FileTransferError::PeerError));

+ return;

+ }

+

+ JingleS5BTransportPayload::Candidate our_candidate = theirCandidates[our_cid];

+ JingleS5BTransportPayload::Candidate their_candidate = ourCandidates[their_cid];

+ if (our_candidate.priority > their_candidate.priority) {

+ useOurCandidateChoiceForTransfer(our_candidate);

+ }

+ else if (our_candidate.priority < their_candidate.priority) {

+ useTheirCandidateChoiceForTransfer(their_candidate);

+ }

+ else {

+ useTheirCandidateChoiceForTransfer(their_candidate);

+ }

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+ else {

+ assert(false);

+ }

+ } else {

+ SWIFT_LOG(debug) << "Can't make a transport decision yet." << std::endl;

+ }

+}

+

+void IncomingJingleFileTransfer::proxySessionReady(const JID& proxy, bool error) {

+ if (error) {

+ // indicate proxy error

+ } else {

+ // activate proxy

+ activateProxySession(proxy);

+ }

+}

+

+void IncomingJingleFileTransfer::activateProxySession(const JID &proxy) {

+ S5BProxyRequest::ref proxyRequest = boost::make_shared<S5BProxyRequest>();

+ proxyRequest->setSID(s5bSessionID);

+ proxyRequest->setActivate(session->getInitiator());

+

+ boost::shared_ptr<GenericRequest<S5BProxyRequest> > request = boost::make_shared<GenericRequest<S5BProxyRequest> >(IQ::Set, proxy, proxyRequest, router);

+ request->onResponse.connect(boost::bind(&IncomingJingleFileTransfer::handleActivateProxySessionResult, this, _1, _2));

+ request->send();

+}

+

+void IncomingJingleFileTransfer::handleActivateProxySessionResult(boost::shared_ptr<S5BProxyRequest> /*request*/, ErrorPayload::ref error) {

+ SWIFT_LOG(debug) << std::endl;

+ if (error) {

+ SWIFT_LOG(debug) << "ERROR" << std::endl;

+ } else {

+ // send activated to other jingle party

+ JingleS5BTransportPayload::ref proxyActivate = boost::make_shared<JingleS5BTransportPayload>();

+ proxyActivate->setActivated(theirCandidate->getCandidateUsed());

+ session->sendTransportInfo(getContentID(), proxyActivate);

+

+ // start transferring

+ clientSession->onBytesReceived.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startReceiving(stream);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+}

+ SWIFT_LOG(debug) << "transport info received" << std::endl;

+ if (state == Terminated) {

+ return;

+ }

+ if (JingleS5BTransportPayload::ref s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transport)) {

+ if (!s5bPayload->getActivated().empty()) {

+ if (ourCandidate->getCandidateUsed() == s5bPayload->getActivated()) {

+ clientSession->onBytesReceived.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startReceiving(stream);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ } else {

+ SWIFT_LOG(debug) << "ourCandidateChoice doesn't match activated proxy candidate!" << std::endl;

+ JingleS5BTransportPayload::ref proxyError = boost::make_shared<JingleS5BTransportPayload>();

+ proxyError->setProxyError(true);

+ proxyError->setSessionID(s5bSessionID);

+ session->sendTransportInfo(getContentID(), proxyError);

+ }

+ } else {

+ theirCandidate = s5bPayload;

+ decideOnUsedTransport();

+ }

+ }

+ else {

+ SWIFT_LOG(debug) << "Expected something different here." << std::endl;

+ }

+ /*localTransportCandidateSelectFinished = true;

+ }*/

+ //checkCandidateSelected();

+ if (state == Terminated) {

+ return;

+ }

+ SWIFT_LOG(debug) << "transport replaced with IBB" << std::endl;

+ session->sendTransportAccept(content, ibbTransport);

+ } else {

+ SWIFT_LOG(debug) << "transport replaced failed" << std::endl;

+ session->sendTransportReject(content, transport);

+ // TODO: getOffer() -> getOffers correction

+ return boost::make_shared<JingleIncomingIBBTransport>(session->getInitiator(), ibbTransport->getSessionID(), description->getOffers()[0].getSize(), router);

+}

+

+JingleContentID IncomingJingleFileTransfer::getContentID() const {

+ return JingleContentID(initialContent->getName(), initialContent->getCreator());

+}

+

+void IncomingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {

+ if (state == Terminated) {

+ return;

+ }

+

+ if (error) {

+ session->sendTerminate(JinglePayload::Reason::ConnectivityError);

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed));

+ onFinished(error);

+ }

+ //

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/Network/Timer.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/Elements/ErrorPayload.h>

+ class SOCKS5BytestreamRegistry;

+ class SOCKS5BytestreamProxy;

+ class IncrementalBytestreamHashCalculator;

+ const JID& ourJID,

+ IQRouter* router,

+ SOCKS5BytestreamRegistry* bytestreamRegistry,

+ SOCKS5BytestreamProxy* bytestreamProxy,

+ TimerFactory*);

+ virtual const JID& getSender() const;

+ void cancel();

+ void handleSessionTerminateReceived(boost::optional<JinglePayload::Reason>);

+ void handleSessionInfoReceived(JinglePayload::ref);

+ void handleWriteStreamDataReceived(const std::vector<unsigned char>& data);

+ JingleContentID getContentID() const;

+ void checkIfAllDataReceived();

+ bool verifyReceviedData();

+ void finishOffTransfer();

+ void handleTransferFinished(boost::optional<FileTransferError>);

+ typedef std::map<std::string, JingleS5BTransportPayload::Candidate> CandidateMap;

+

+ private:

+ void activateProxySession(const JID &proxy);

+ void handleActivateProxySessionResult(boost::shared_ptr<S5BProxyRequest> request, ErrorPayload::ref error);

+ void proxySessionReady(const JID& proxy, bool error);

+

+ private:

+ void useOurCandidateChoiceForTransfer(JingleS5BTransportPayload::Candidate candidate);

+ void useTheirCandidateChoiceForTransfer(JingleS5BTransportPayload::Candidate candidate);

+ void decideOnUsedTransport();

+ void fillCandidateMap(CandidateMap& map, JingleS5BTransportPayload::ref s5bPayload);

+

+ private:

+ JID ourJID;

+ TimerFactory* timerFactory;

+ uintmax_t receivedBytes;

+ IncrementalBytestreamHashCalculator* hashCalculator;

+ Timer::ref waitOnHashTimer;

+ IDGenerator idGenerator;

+

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamProxy* s5bProxy;

+ JingleS5BTransportPayload::ref ourCandidate;

+ JingleS5BTransportPayload::ref theirCandidate;

+ CandidateMap ourCandidates;

+ CandidateMap theirCandidates;

+ SOCKS5BytestreamClientSession::ref clientSession;

+ std::string s5bDestination;

+ std::string s5bSessionID;

+ SOCKS5BytestreamServerSession* serverSession;

+

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swiften/FileTransfer/IncrementalBytestreamHashCalculator.h>

+

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/StringCodecs/MD5.h>

+#include <Swiften/StringCodecs/SHA1.h>

+

+namespace Swift {

+

+IncrementalBytestreamHashCalculator::IncrementalBytestreamHashCalculator(bool doMD5, bool doSHA1) {

+ md5Hasher = doMD5 ? new MD5() : NULL;

+ sha1Hasher = doSHA1 ? new SHA1() : NULL;

+}

+

+IncrementalBytestreamHashCalculator::~IncrementalBytestreamHashCalculator() {

+ delete md5Hasher;

+ delete sha1Hasher;

+}

+

+void IncrementalBytestreamHashCalculator::feedData(const ByteArray& data) {

+ if (md5Hasher) {

+ md5Hasher->update(data);

+ }

+ if (sha1Hasher) {

+ sha1Hasher->update(data);

+ }

+}

+/*

+void IncrementalBytestreamHashCalculator::feedData(const SafeByteArray& data) {

+ if (md5Hasher) {

+ md5Hasher->update(createByteArray(data.data(), data.size()));

+ }

+ if (sha1Hasher) {

+ sha1Hasher->update(createByteArray(data.data(), data.size()));

+ }

+}*/

+

+std::string IncrementalBytestreamHashCalculator::getSHA1String() {

+ if (sha1Hasher) {

+ ByteArray result = sha1Hasher->getHash();

+ return Hexify::hexify(result);

+ } else {

+ return std::string();

+ }

+}

+

+std::string IncrementalBytestreamHashCalculator::getMD5String() {

+ if (md5Hasher) {

+ ByteArray result = md5Hasher->getHash();

+ return Hexify::hexify(result);

+ } else {

+ return std::string();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/Base/SafeByteArray.h>

+

+namespace Swift {

+

+class MD5;

+class SHA1;

+

+class IncrementalBytestreamHashCalculator {

+public:

+ IncrementalBytestreamHashCalculator(bool doMD5, bool doSHA1);

+ ~IncrementalBytestreamHashCalculator();

+

+ void feedData(const ByteArray& data);

+ //void feedData(const SafeByteArray& data);

+

+ std::string getSHA1String();

+ std::string getMD5String();

+

+private:

+ MD5* md5Hasher;

+ SHA1* sha1Hasher;

+};

+

+}

+JingleIncomingIBBTransport::JingleIncomingIBBTransport(const JID& from, const std::string& id, size_t size, IQRouter* router) : ibbSession(id, from, size, router) {

+ ibbSession.onFinished.connect(boost::ref(onFinished));

+#include <Swiften/FileTransfer/FileTransfer.h>

+ boost::signal<void (boost::optional<FileTransferError>)> onFinished;

+ /**

+ * Should call onLocalTransportCandidatesGenerated if it has finished discovering local candidates.

+ */

+ virtual void generateLocalTransportCandidates(JingleTransportPayload::ref) = 0;

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/FileTransfer/FileTransfer.h>

+

+ class OutgoingFileTransfer : public FileTransfer {

+ public:

+ typedef boost::shared_ptr<OutgoingFileTransfer> ref;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "OutgoingFileTransferManager.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/JID/JID.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

+#include <Swiften/Jingle/JingleSessionImpl.h>

+#include <Swiften/Jingle/JingleContentID.h>

+#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

+#include <Swiften/Base/IDGenerator.h>

+

+namespace Swift {

+

+OutgoingFileTransferManager::OutgoingFileTransferManager(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, RemoteJingleTransportCandidateSelectorFactory* remoteFactory, LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy) : ownJID(ownFullJID), jsManager(jingleSessionManager), iqRouter(router), capsProvider(capsProvider), remoteFactory(remoteFactory), localFactory(localFactory), bytestreamRegistry(bytestreamRegistry), bytestreamProxy(bytestreamProxy) {

+ idGenerator = new IDGenerator();

+}

+

+OutgoingFileTransferManager::~OutgoingFileTransferManager() {

+ delete idGenerator;

+}

+

+boost::shared_ptr<OutgoingFileTransfer> OutgoingFileTransferManager::createOutgoingFileTransfer(const JID& receipient, boost::shared_ptr<ReadBytestream> readBytestream, const StreamInitiationFileInfo& fileInfo) {

+ // check if receipient support Jingle FT

+

+

+ JingleSessionImpl::ref jingleSession = boost::make_shared<JingleSessionImpl>(ownJID, receipient, idGenerator->generateID(), iqRouter);

+

+ //jsManager->getSession(receipient, idGenerator->generateID());

+ assert(jingleSession);

+ jsManager->registerOutgoingSession(ownJID, jingleSession);

+ boost::shared_ptr<OutgoingJingleFileTransfer> jingleFT = boost::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(jingleSession, remoteFactory, localFactory, iqRouter, idGenerator, receipient, readBytestream, fileInfo, bytestreamRegistry, bytestreamProxy));

+

+ // otherwise try SI

+

+ // else fail

+

+ return jingleFT;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+

+class JingleSessionManager;

+class IQRouter;

+class EntityCapsProvider;

+class RemoteJingleTransportCandidateSelectorFactory;

+class LocalJingleTransportCandidateGeneratorFactory;

+class OutgoingFileTransfer;

+class JID;

+class IDGenerator;

+class ReadBytestream;

+class StreamInitiationFileInfo;

+class SOCKS5BytestreamRegistry;

+class SOCKS5BytestreamProxy;

+

+class OutgoingFileTransferManager {

+public:

+ OutgoingFileTransferManager(const JID& ownFullJID, JingleSessionManager* jingleSessionManager, IQRouter* router, EntityCapsProvider* capsProvider, RemoteJingleTransportCandidateSelectorFactory* remoteFactory, LocalJingleTransportCandidateGeneratorFactory* localFactory, SOCKS5BytestreamRegistry* bytestreamRegistry, SOCKS5BytestreamProxy* bytestreamProxy);

+ ~OutgoingFileTransferManager();

+

+ boost::shared_ptr<OutgoingFileTransfer> createOutgoingFileTransfer(const JID&, boost::shared_ptr<ReadBytestream>, const StreamInitiationFileInfo&);

+

+private:

+ JID ownJID;

+ JingleSessionManager* jsManager;

+ IQRouter* iqRouter;

+ EntityCapsProvider* capsProvider;

+ RemoteJingleTransportCandidateSelectorFactory* remoteFactory;

+ LocalJingleTransportCandidateGeneratorFactory* localFactory;

+ IDGenerator *idGenerator;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+ SOCKS5BytestreamProxy* bytestreamProxy;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "OutgoingJingleFileTransfer.h"

+

+#include <boost/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/Jingle/JingleContentID.h>

+#include <Swiften/Elements/JingleFileTransferDescription.h>

+#include <Swiften/Elements/JingleFileTransferHash.h>

+#include <Swiften/Elements/JingleTransportPayload.h>

+#include <Swiften/Elements/JingleIBBTransportPayload.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/Queries/GenericRequest.h>

+#include <Swiften/FileTransfer/IBBSendSession.h>

+#include <Swiften/FileTransfer/IncrementalBytestreamHashCalculator.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/StringCodecs/SHA1.h>

+

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+OutgoingJingleFileTransfer::OutgoingJingleFileTransfer(JingleSession::ref session,

+ RemoteJingleTransportCandidateSelectorFactory* remoteFactory,

+ LocalJingleTransportCandidateGeneratorFactory* localFactory,

+ IQRouter* router,

+ IDGenerator *idGenerator,

+ const JID& toJID,

+ boost::shared_ptr<ReadBytestream> readStream,

+ const StreamInitiationFileInfo &fileInfo,

+ SOCKS5BytestreamRegistry* bytestreamRegistry,

+ SOCKS5BytestreamProxy* bytestreamProxy) :

+ session(session), remoteFactory(remoteFactory), localFactory(localFactory), router(router), idGenerator(idGenerator), toJID(toJID), readStream(readStream), fileInfo(fileInfo), s5bRegistry(bytestreamRegistry), s5bProxy(bytestreamProxy), serverSession(NULL), contentID(JingleContentID(idGenerator->generateID(), JingleContentPayload::InitiatorCreator)), canceled(false) {

+ session->onSessionAcceptReceived.connect(boost::bind(&OutgoingJingleFileTransfer::handleSessionAcceptReceived, this, _1, _2, _3));

+ session->onSessionTerminateReceived.connect(boost::bind(&OutgoingJingleFileTransfer::handleSessionTerminateReceived, this, _1));

+ session->onTransportInfoReceived.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransportInfoReceived, this, _1, _2));

+ session->onTransportAcceptReceived.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransportAcceptReceived, this, _1, _2));

+ fileSizeInBytes = fileInfo.getSize();

+ filename = fileInfo.getName();

+

+ localCandidateGenerator = localFactory->createCandidateGenerator();

+ localCandidateGenerator->onLocalTransportCandidatesGenerated.connect(boost::bind(&OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated, this, _1));

+

+ remoteCandidateSelector = remoteFactory->createCandidateSelector();

+ remoteCandidateSelector->onRemoteTransportCandidateSelectFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleRemoteTransportCandidateSelectFinished, this, _1));

+ // calculate both, MD5 and SHA-1 since we don't know which one the other side supports

+ hashCalculator = new IncrementalBytestreamHashCalculator(true, true);

+ this->readStream->onRead.connect(boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+}

+

+OutgoingJingleFileTransfer::~OutgoingJingleFileTransfer() {

+ readStream->onRead.disconnect(boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+ delete hashCalculator;

+}

+

+void OutgoingJingleFileTransfer::start() {

+ onStateChange(FileTransfer::State(FileTransfer::State::WaitingForStart));

+

+ s5bSessionID = s5bRegistry->generateSessionID();

+ SWIFT_LOG(debug) << "S5B SessionID: " << s5bSessionID << std::endl;

+

+ //s5bProxy->connectToProxies(s5bSessionID);

+

+ JingleS5BTransportPayload::ref transport = boost::make_shared<JingleS5BTransportPayload>();

+ localCandidateGenerator->generateLocalTransportCandidates(transport);

+}

+

+void OutgoingJingleFileTransfer::stop() {

+

+}

+

+void OutgoingJingleFileTransfer::cancel() {

+ canceled = true;

+ session->sendTerminate(JinglePayload::Reason::Cancel);

+

+ if (ibbSession) {

+ ibbSession->stop();

+ }

+ SOCKS5BytestreamServerSession *serverSession = s5bRegistry->getConnectedSession(SOCKS5BytestreamRegistry::getHostname(s5bSessionID, session->getInitiator(), toJID));

+ if (serverSession) {

+ serverSession->stop();

+ }

+ if (clientSession) {

+ clientSession->stop();

+ }

+ onStateChange(FileTransfer::State(FileTransfer::State::Canceled));

+}

+

+void OutgoingJingleFileTransfer::handleSessionAcceptReceived(const JingleContentID& id, JingleDescription::ref /* decription */, JingleTransportPayload::ref transportPayload) {

+ if (canceled) {

+ return;

+ }

+ onStateChange(FileTransfer::State(FileTransfer::State::Negotiating));

+

+ JingleIBBTransportPayload::ref ibbPayload;

+ JingleS5BTransportPayload::ref s5bPayload;

+ if ((ibbPayload = boost::dynamic_pointer_cast<JingleIBBTransportPayload>(transportPayload))) {

+ ibbSession = boost::make_shared<IBBSendSession>(ibbPayload->getSessionID(), toJID, readStream, router);

+ ibbSession->setBlockSize(ibbPayload->getBlockSize());

+ ibbSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ ibbSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ ibbSession->start();

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+ else if ((s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload))) {

+ fillCandidateMap(theirCandidates, s5bPayload);

+ remoteCandidateSelector->setRequesterTargtet(toJID, session->getInitiator());

+ remoteCandidateSelector->addRemoteTransportCandidates(s5bPayload);

+ remoteCandidateSelector->selectCandidate();

+ }

+ else {

+ // TODO: error handling

+ SWIFT_LOG(debug) << "Unknown transport payload! Try replaceing with IBB." << std::endl;

+ replaceTransportWithIBB(id);

+ }

+}

+

+void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

+ if (canceled) {

+ return;

+ }

+

+ if (ibbSession) {

+ ibbSession->stop();

+ }

+ if (clientSession) {

+ clientSession->stop();

+ }

+ if (serverSession) {

+ serverSession->stop();

+ }

+

+ if (reason.is_initialized() && reason.get().type == JinglePayload::Reason::Cancel) {

+ onStateChange(FileTransfer::State(FileTransfer::State::Canceled));

+ onFinished(FileTransferError(FileTransferError::PeerError));

+ } else if (reason.is_initialized() && reason.get().type == JinglePayload::Reason::Success) {

+ onStateChange(FileTransfer::State(FileTransfer::State::Finished));

+ onFinished(boost::optional<FileTransferError>());

+ } else {

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed));

+ onFinished(FileTransferError(FileTransferError::PeerError));

+ }

+ canceled = true;

+}

+

+void OutgoingJingleFileTransfer::handleTransportAcceptReceived(const JingleContentID& /* contentID */, JingleTransportPayload::ref transport) {

+ if (canceled) {

+ return;

+ }

+

+ if (JingleIBBTransportPayload::ref ibbPayload = boost::dynamic_pointer_cast<JingleIBBTransportPayload>(transport)) {

+ ibbSession = boost::make_shared<IBBSendSession>(ibbPayload->getSessionID(), toJID, readStream, router);

+ ibbSession->setBlockSize(ibbPayload->getBlockSize());

+ ibbSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ ibbSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ ibbSession->start();

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ } else {

+ // error handling

+ SWIFT_LOG(debug) << "Replacing with anything other than IBB isn't supported yet." << std::endl;

+ session->sendTerminate(JinglePayload::Reason::FailedTransport);

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed));

+ }

+}

+

+void OutgoingJingleFileTransfer::startTransferViaOurCandidateChoice(JingleS5BTransportPayload::Candidate candidate) {

+ SWIFT_LOG(debug) << "Transferring data using our candidate." << std::endl;

+ if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ // get proxy client session from remoteCandidateSelector

+ clientSession = remoteCandidateSelector->getS5BSession();

+

+ // wait on <activated/> transport-info

+ } else {

+ clientSession = remoteCandidateSelector->getS5BSession();

+ clientSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startSending(readStream);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+ assert(clientSession);

+}

+

+void OutgoingJingleFileTransfer::startTransferViaTheirCandidateChoice(JingleS5BTransportPayload::Candidate candidate) {

+ SWIFT_LOG(debug) << "Transferring data using their candidate." << std::endl;

+ if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ // connect to proxy

+ clientSession = s5bProxy->createSOCKS5BytestreamClientSession(candidate.hostPort, SOCKS5BytestreamRegistry::getHostname(s5bSessionID, session->getInitiator(), toJID));

+ clientSession->onSessionReady.connect(boost::bind(&OutgoingJingleFileTransfer::proxySessionReady, this, candidate.jid, _1));

+ clientSession->start();

+

+ // on reply send activate

+

+ } else {

+ serverSession = s5bRegistry->getConnectedSession(SOCKS5BytestreamRegistry::getHostname(s5bSessionID, session->getInitiator(), toJID));

+ serverSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ serverSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ serverSession->startTransfer();

+ }

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+}

+

+// decide on candidates according to http://xmpp.org/extensions/xep-0260.html#complete

+void OutgoingJingleFileTransfer::decideOnCandidates() {

+ if (ourCandidateChoice && theirCandidateChoice) {

+ std::string our_cid = ourCandidateChoice->getCandidateUsed();

+ std::string their_cid = theirCandidateChoice->getCandidateUsed();

+ if (ourCandidateChoice->hasCandidateError() && theirCandidateChoice->hasCandidateError()) {

+ replaceTransportWithIBB(contentID);

+ }

+ else if (!our_cid.empty() && theirCandidateChoice->hasCandidateError()) {

+ // use our candidate

+ startTransferViaOurCandidateChoice(theirCandidates[our_cid]);

+ }

+ else if (!their_cid.empty() && ourCandidateChoice->hasCandidateError()) {

+ // use their candidate

+ startTransferViaTheirCandidateChoice(ourCandidates[their_cid]);

+ }

+ else if (!our_cid.empty() && !their_cid.empty()) {

+ // compare priorites, if same we win

+ if (ourCandidates.find(their_cid) == ourCandidates.end() || theirCandidates.find(our_cid) == theirCandidates.end()) {

+ SWIFT_LOG(debug) << "Didn't recognize candidate IDs!" << std::endl;

+ session->sendTerminate(JinglePayload::Reason::FailedTransport);

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed));

+ onFinished(FileTransferError(FileTransferError::PeerError));

+ return;

+ }

+

+ JingleS5BTransportPayload::Candidate ourCandidate = theirCandidates[our_cid];

+ JingleS5BTransportPayload::Candidate theirCandidate = ourCandidates[their_cid];

+ if (ourCandidate.priority > theirCandidate.priority) {

+ startTransferViaOurCandidateChoice(ourCandidate);

+ }

+ else if (ourCandidate.priority < theirCandidate.priority) {

+ startTransferViaTheirCandidateChoice(theirCandidate);

+ }

+ else {

+ startTransferViaOurCandidateChoice(ourCandidate);

+ }

+ }

+ } else {

+ SWIFT_LOG(debug) << "Can't make a decision yet!" << std::endl;

+ }

+}

+

+void OutgoingJingleFileTransfer::fillCandidateMap(CandidateMap& map, JingleS5BTransportPayload::ref s5bPayload) {

+ map.clear();

+ foreach (JingleS5BTransportPayload::Candidate candidate, s5bPayload->getCandidates()) {

+ map[candidate.cid] = candidate;

+ }

+}

+

+void OutgoingJingleFileTransfer::proxySessionReady(const JID& proxy, bool error) {

+ if (error) {

+ // indicate proxy error

+ } else {

+ // activate proxy

+ activateProxySession(proxy);

+ }

+}

+

+void OutgoingJingleFileTransfer::activateProxySession(const JID& proxy) {

+ S5BProxyRequest::ref proxyRequest = boost::make_shared<S5BProxyRequest>();

+ proxyRequest->setSID(s5bSessionID);

+ proxyRequest->setActivate(toJID);

+

+ boost::shared_ptr<GenericRequest<S5BProxyRequest> > request = boost::make_shared<GenericRequest<S5BProxyRequest> >(IQ::Set, proxy, proxyRequest, router);

+ request->onResponse.connect(boost::bind(&OutgoingJingleFileTransfer::handleActivateProxySessionResult, this, _1, _2));

+ request->send();

+}

+

+void OutgoingJingleFileTransfer::handleActivateProxySessionResult(boost::shared_ptr<S5BProxyRequest> /*request*/, ErrorPayload::ref error) {

+ if (error) {

+ SWIFT_LOG(debug) << "ERROR" << std::endl;

+ } else {

+ // send activated to other jingle party

+ JingleS5BTransportPayload::ref proxyActivate = boost::make_shared<JingleS5BTransportPayload>();

+ proxyActivate->setActivated(theirCandidateChoice->getCandidateUsed());

+ session->sendTransportInfo(contentID, proxyActivate);

+

+ // start transferring

+ clientSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startSending(readStream);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ }

+}

+

+void OutgoingJingleFileTransfer::sendSessionInfoHash() {

+ SWIFT_LOG(debug) << std::endl;

+ JingleFileTransferHash::ref hashElement = boost::make_shared<JingleFileTransferHash>();

+ hashElement->setHash("sha-1", hashCalculator->getSHA1String());

+ hashElement->setHash("md5", hashCalculator->getMD5String());

+ session->sendInfo(hashElement);

+}

+

+void OutgoingJingleFileTransfer::handleTransportInfoReceived(const JingleContentID& /* contentID */, JingleTransportPayload::ref transport) {

+ if (canceled) {

+ return;

+ }

+ if (JingleS5BTransportPayload::ref s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transport)) {

+ if (s5bPayload->hasCandidateError() || !s5bPayload->getCandidateUsed().empty()) {

+ theirCandidateChoice = s5bPayload;

+ decideOnCandidates();

+ } else if(!s5bPayload->getActivated().empty()) {

+ if (ourCandidateChoice->getCandidateUsed() == s5bPayload->getActivated()) {

+ clientSession->onBytesSent.connect(boost::bind(boost::ref(onProcessedBytes), _1));

+ clientSession->onFinished.connect(boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ clientSession->startSending(readStream);

+ onStateChange(FileTransfer::State(FileTransfer::State::Transferring));

+ } else {

+ SWIFT_LOG(debug) << "ourCandidateChoice doesn't match activated proxy candidate!" << std::endl;

+ JingleS5BTransportPayload::ref proxyError = boost::make_shared<JingleS5BTransportPayload>();

+ proxyError->setProxyError(true);

+ proxyError->setSessionID(s5bSessionID);

+ session->sendTransportInfo(contentID, proxyError);

+ }

+ }

+ }

+}

+

+void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(JingleTransportPayload::ref payload) {

+ if (canceled) {

+ return;

+ }

+ JingleFileTransferDescription::ref description = boost::make_shared<JingleFileTransferDescription>();

+ description->addOffer(fileInfo);

+

+ JingleTransportPayload::ref transport;

+ if (JingleIBBTransportPayload::ref ibbTransport = boost::dynamic_pointer_cast<JingleIBBTransportPayload>(payload)) {

+ ibbTransport->setBlockSize(4096);

+ ibbTransport->setSessionID(idGenerator->generateID());

+ transport = ibbTransport;

+ }

+ else if (JingleS5BTransportPayload::ref s5bTransport = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(payload)) {

+ //fillCandidateMap(ourCandidates, s5bTransport);

+ //s5bTransport->setSessionID(s5bSessionID);

+

+ JingleS5BTransportPayload::ref emptyCandidates = boost::make_shared<JingleS5BTransportPayload>();

+ emptyCandidates->setSessionID(s5bTransport->getSessionID());

+ fillCandidateMap(ourCandidates, emptyCandidates);

+

+ transport = emptyCandidates;

+ s5bRegistry->addReadBytestream(SOCKS5BytestreamRegistry::getHostname(s5bSessionID, session->getInitiator(), toJID), readStream);

+ }

+ else {

+ SWIFT_LOG(debug) << "Unknown tranport payload: " << typeid(*payload).name() << std::endl;

+ return;

+ }

+ session->sendInitiate(contentID, description, transport);

+ onStateChange(FileTransfer::State(FileTransfer::State::WaitingForAccept));

+}

+

+void OutgoingJingleFileTransfer::handleRemoteTransportCandidateSelectFinished(JingleTransportPayload::ref payload) {

+ if (canceled) {

+ return;

+ }

+ if (JingleS5BTransportPayload::ref s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(payload)) {

+ ourCandidateChoice = s5bPayload;

+ session->sendTransportInfo(contentID, s5bPayload);

+ decideOnCandidates();

+ }

+}

+

+void OutgoingJingleFileTransfer::replaceTransportWithIBB(const JingleContentID& id) {

+ SWIFT_LOG(debug) << "Both parties failed. Replace transport with IBB." << std::endl;

+ JingleIBBTransportPayload::ref ibbTransport = boost::make_shared<JingleIBBTransportPayload>();

+ ibbTransport->setBlockSize(4096);

+ ibbTransport->setSessionID(idGenerator->generateID());

+ session->sendTransportReplace(id, ibbTransport);

+}

+

+void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {

+ if (error) {

+ session->sendTerminate(JinglePayload::Reason::ConnectivityError);

+ onStateChange(FileTransfer::State(FileTransfer::State::Failed));

+ onFinished(error);

+ } else {

+ sendSessionInfoHash();

+ /*

+ session->terminate(JinglePayload::Reason::Success);

+ onStateChange(FileTransfer::State(FileTransfer::State::Finished));

+ */

+ }

+ //

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swiften/Elements/JingleContentPayload.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/Elements/StreamInitiationFileInfo.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/Elements/ErrorPayload.h>

+#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>

+#include <Swiften/Jingle/JingleContentID.h>

+#include <Swiften/Jingle/JingleSession.h>

+#include <Swiften/StringCodecs/SHA1.h>

+

+namespace Swift {

+

+class RemoteJingleTransportCandidateSelectorFactory;

+class RemoteJingleTransportCandidateSelector;

+class LocalJingleTransportCandidateGeneratorFactory;

+class LocalJingleTransportCandidateGenerator;

+class IQRouter;

+class ReadBytestream;

+class IBBSendSession;

+class IDGenerator;

+class IncrementalBytestreamHashCalculator;

+class SOCKS5BytestreamRegistry;

+class SOCKS5BytestreamProxy;

+

+class OutgoingJingleFileTransfer : public OutgoingFileTransfer {

+public:

+ OutgoingJingleFileTransfer(JingleSession::ref,

+ RemoteJingleTransportCandidateSelectorFactory*,

+ LocalJingleTransportCandidateGeneratorFactory*,

+ IQRouter*,

+ IDGenerator*,

+ const JID&,

+ boost::shared_ptr<ReadBytestream>,

+ const StreamInitiationFileInfo&,

+ SOCKS5BytestreamRegistry*,

+ SOCKS5BytestreamProxy*);

+ virtual ~OutgoingJingleFileTransfer();

+

+ void start();

+ void stop();

+

+ void cancel();

+

+private:

+ void handleSessionAcceptReceived(const JingleContentID&, JingleDescription::ref, JingleTransportPayload::ref);

+ void handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason);

+ void handleTransportAcceptReceived(const JingleContentID&, JingleTransportPayload::ref);

+ void handleTransportInfoReceived(const JingleContentID&, JingleTransportPayload::ref);

+

+ void handleLocalTransportCandidatesGenerated(JingleTransportPayload::ref);

+ void handleRemoteTransportCandidateSelectFinished(JingleTransportPayload::ref);

+

+private:

+ void replaceTransportWithIBB(const JingleContentID&);

+ void handleTransferFinished(boost::optional<FileTransferError>);

+ void activateProxySession(const JID &proxy);

+ void handleActivateProxySessionResult(boost::shared_ptr<S5BProxyRequest> request, ErrorPayload::ref error);

+ void proxySessionReady(const JID& proxy, bool error);

+

+private:

+ typedef std::map<std::string, JingleS5BTransportPayload::Candidate> CandidateMap;

+

+private:

+ void startTransferViaOurCandidateChoice(JingleS5BTransportPayload::Candidate);

+ void startTransferViaTheirCandidateChoice(JingleS5BTransportPayload::Candidate);

+ void decideOnCandidates();

+ void fillCandidateMap(CandidateMap& map, JingleS5BTransportPayload::ref s5bPayload);

+

+private:

+ void sendSessionInfoHash();

+

+private:

+ JingleSession::ref session;

+ RemoteJingleTransportCandidateSelector* remoteCandidateSelector;

+ RemoteJingleTransportCandidateSelectorFactory* remoteFactory;

+ LocalJingleTransportCandidateGenerator* localCandidateGenerator;

+ LocalJingleTransportCandidateGeneratorFactory* localFactory;

+

+ IQRouter* router;

+ IDGenerator* idGenerator;

+ JID toJID;

+ boost::shared_ptr<ReadBytestream> readStream;

+ StreamInitiationFileInfo fileInfo;

+ IncrementalBytestreamHashCalculator *hashCalculator;

+

+ boost::shared_ptr<IBBSendSession> ibbSession;

+

+ JingleS5BTransportPayload::ref ourCandidateChoice;

+ JingleS5BTransportPayload::ref theirCandidateChoice;

+ CandidateMap ourCandidates;

+ CandidateMap theirCandidates;

+

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamProxy* s5bProxy;

+ SOCKS5BytestreamClientSession::ref clientSession;

+ SOCKS5BytestreamServerSession* serverSession;

+ JingleContentID contentID;

+ std::string s5bSessionID;

+

+ bool canceled;

+};

+

+}

+ socksServer->addReadBytestream(id, from, to, bytestream);

+ socksServer->removeReadBytestream(id, from, to);

+#include <Swiften/Base/boost_bsignals.h>

+

+

+ public:

+ boost::signal<void (std::vector<unsigned char>)> onRead;

+#include <Swiften/JID/JID.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+ virtual void setRequesterTargtet(const JID&, const JID&) {}

+ virtual SOCKS5BytestreamClientSession::ref getS5BSession() { return SOCKS5BytestreamClientSession::ref(); }

+ "OutgoingJingleFileTransfer.cpp",

+ "OutgoingFileTransferManager.cpp",

+ "OutgoingFileTransferManager.cpp",

+ "DefaultRemoteJingleTransportCandidateSelectorFactory.cpp",

+ "DefaultLocalJingleTransportCandidateGeneratorFactory.cpp",

+ "DefaultRemoteJingleTransportCandidateSelector.cpp",

+ "DefaultLocalJingleTransportCandidateGenerator.cpp",

+ "SOCKS5BytestreamClientSession.cpp",

+ "SOCKS5BytestreamProxy.cpp",

+ "FileTransferManager.cpp",

+ "FileTransferManagerImpl.cpp",

+ "IncrementalBytestreamHashCalculator.cpp",

+ "ConnectivityManager.cpp",

+ File("UnitTest/SOCKS5BytestreamClientSessionTest.cpp"),

+ File("UnitTest/IncomingJingleFileTransferTest.cpp"),

+ File("UnitTest/OutgoingJingleFileTransferTest.cpp"),

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "SOCKS5BytestreamClientSession.h"

+

+#include <boost/bind.hpp>

+

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/SafeByteArray.h>

+#include <Swiften/Base/Concat.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/StringCodecs/SHA1.h>

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/FileTransfer/BytestreamException.h>

+#include <Swiften/Network/TimerFactory.h>

+

+namespace Swift {

+

+SOCKS5BytestreamClientSession::SOCKS5BytestreamClientSession(boost::shared_ptr<Connection> connection, const HostAddressPort& addressPort, const std::string& destination, TimerFactory* timerFactory) :

+ connection(connection), addressPort(addressPort), destination(destination), state(Initial), chunkSize(131072) {

+ connection->onConnectFinished.connect(boost::bind(&SOCKS5BytestreamClientSession::handleConnectFinished, this, _1));

+ connection->onDisconnected.connect(boost::bind(&SOCKS5BytestreamClientSession::handleDisconnected, this, _1));

+ weFailedTimeout = timerFactory->createTimer(2000);

+ weFailedTimeout->onTick.connect(boost::bind(&SOCKS5BytestreamClientSession::handleWeFailedTimeout, this));

+}

+

+void SOCKS5BytestreamClientSession::start() {

+ assert(state == Initial);

+ SWIFT_LOG(debug) << "Trying to connect via TCP to " << addressPort.toString() << "." << std::endl;

+ weFailedTimeout->start();

+ connection->connect(addressPort);

+}

+

+void SOCKS5BytestreamClientSession::stop() {

+ connection->disconnect();

+ connection->onDataWritten.disconnect(boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

+ connection->onDataRead.disconnect(boost::bind(&SOCKS5BytestreamClientSession::handleDataRead, this, _1));

+ readBytestream.reset();

+ state = Finished;

+}

+

+void SOCKS5BytestreamClientSession::process() {

+ SWIFT_LOG(debug) << "unprocessedData.size(): " << unprocessedData.size() << std::endl;

+ ByteArray bndAddress;

+ switch(state) {

+ case Initial:

+ hello();

+ break;

+ case Hello:

+ if (unprocessedData.size() > 1) {

+ unsigned char version = unprocessedData[0];

+ unsigned char authMethod = unprocessedData[1];

+ if (version != 5 || authMethod != 0) {

+ // signal failure to upper level

+ finish(true);

+ return;

+ }

+ unprocessedData.clear();

+ authenticate();

+ }

+ break;

+ case Authenticating:

+ if (unprocessedData.size() < 5) {

+ // need more data to start progressing

+ break;

+ }

+ if (unprocessedData[0] != '\x05') {

+ // wrong version

+ // disconnect & signal failure

+ finish(true);

+ break;

+ }

+ if (unprocessedData[1] != '\x00') {

+ // no success

+ // disconnect & signal failure

+ finish(true);

+ break;

+ }

+ if (unprocessedData[3] != '\x03') {

+ // we expect x'03' = DOMAINNAME here

+ // discconect & signal failure

+ finish(true);

+ break;

+ }

+ if (static_cast<size_t>(unprocessedData[4]) + 1 > unprocessedData.size() + 5) {

+ // complete domainname and port not available yet

+ break;

+ }

+ bndAddress = createByteArray(&(unprocessedData.data()[5]), unprocessedData[4]);

+ if (unprocessedData[unprocessedData[4] + 5] != 0 && bndAddress == createByteArray(destination)) {

+ // we expect a 0 as port

+ // disconnect and fail

+ finish(true);

+ }

+ unprocessedData.clear();

+ state = Ready;

+ SWIFT_LOG(debug) << "session ready" << std::endl;

+ // issue ready signal so the bytestream can be used for reading or writing

+ weFailedTimeout->stop();

+ onSessionReady(false);

+ break;

+ case Ready:

+ SWIFT_LOG(debug) << "Received further data in Ready state." << std::endl;

+ break;

+ case Reading:

+ case Writing:

+ case Finished:

+ SWIFT_LOG(debug) << "Unexpected receive of data. Current state: " << state << std::endl;

+ SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData) << std::endl;

+ unprocessedData.clear();

+ //assert(false);

+ }

+}

+

+void SOCKS5BytestreamClientSession::hello() {

+ // Version 5, 1 auth method, No authentication

+ const SafeByteArray hello = createSafeByteArray("\x05\x01\x00", 3);

+ connection->write(hello);

+ state = Hello;

+}

+

+void SOCKS5BytestreamClientSession::authenticate() {

+ SWIFT_LOG(debug) << std::endl;

+ SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4);

+ SafeByteArray message = header;

+ append(message, createSafeByteArray(destination.size()));

+ authenticateAddress = createByteArray(destination);

+ append(message, authenticateAddress);

+ append(message, createSafeByteArray("\x00\x00", 2)); // 2 byte for port

+ connection->write(message);

+ state = Authenticating;

+}

+

+void SOCKS5BytestreamClientSession::startReceiving(boost::shared_ptr<WriteBytestream> writeStream) {

+ if (state == Ready) {

+ state = Reading;

+ writeBytestream = writeStream;

+ writeBytestream->write(unprocessedData);

+ onBytesReceived(unprocessedData.size());

+ unprocessedData.clear();

+ } else {

+ SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

+ }

+}

+

+void SOCKS5BytestreamClientSession::startSending(boost::shared_ptr<ReadBytestream> readStream) {

+ if (state == Ready) {

+ state = Writing;

+ readBytestream = readStream;

+ connection->onDataWritten.connect(boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

+ sendData();

+ } else {

+ SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

+ }

+}

+

+HostAddressPort SOCKS5BytestreamClientSession::getAddressPort() const {

+ return addressPort;

+}

+

+void SOCKS5BytestreamClientSession::sendData() {

+ if (!readBytestream->isFinished()) {

+ try {

+ SafeByteArray dataToSend = createSafeByteArray(readBytestream->read(chunkSize));

+ connection->write(dataToSend);

+ onBytesSent(dataToSend.size());

+ }

+ catch (const BytestreamException&) {

+ finish(true);

+ }

+ }

+ else {

+ finish(false);

+ }

+}

+

+void SOCKS5BytestreamClientSession::finish(bool error) {

+ weFailedTimeout->stop();

+ connection->disconnect();

+ connection->onDataWritten.disconnect(boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

+ connection->onDataRead.disconnect(boost::bind(&SOCKS5BytestreamClientSession::handleDataRead, this, _1));

+ readBytestream.reset();

+ if (state == Initial || state == Hello || state == Authenticating) {

+ onSessionReady(true);

+ }

+ else {

+ state = Finished;

+ if (error) {

+ onFinished(boost::optional<FileTransferError>(FileTransferError::ReadError));

+ } else {

+ onFinished(boost::optional<FileTransferError>());

+ }

+ }

+}

+

+void SOCKS5BytestreamClientSession::handleConnectFinished(bool error) {

+ if (error) {

+ SWIFT_LOG(debug) << "Failed to connect via TCP to " << addressPort.toString() << "." << std::endl;

+ finish(true);

+ } else {

+ SWIFT_LOG(debug) << "Successfully connected via TCP" << addressPort.toString() << "." << std::endl;

+ weFailedTimeout->start();

+ connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSession::handleDataRead, this, _1));

+ process();

+ }

+}

+

+void SOCKS5BytestreamClientSession::handleDataRead(const SafeByteArray& data) {

+ SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data.size() << std::endl;

+ if (state != Reading) {

+ append(unprocessedData, data);

+ process();

+ }

+ else {

+ writeBytestream->write(createByteArray(data.data(), data.size()));

+ onBytesReceived(data.size());

+ }

+}

+

+void SOCKS5BytestreamClientSession::handleDisconnected(const boost::optional<Connection::Error>& error) {

+ SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl;

+ if (error) {

+ finish(true);

+ }

+}

+

+void SOCKS5BytestreamClientSession::handleWeFailedTimeout() {

+ SWIFT_LOG(debug) << "Failed due to timeout!" << std::endl;

+ finish(true);

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <boost/optional.hpp>

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/FileTransfer/FileTransferError.h>

+#include <Swiften/FileTransfer/WriteBytestream.h>

+#include <Swiften/FileTransfer/ReadBytestream.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Network/Connection.h>

+#include <Swiften/Network/HostAddressPort.h>

+#include <Swiften/Network/Timer.h>

+

+namespace Swift {

+

+class SOCKS5BytestreamRegistry;

+class Connection;

+class TimerFactory;

+

+/**

+ * A session which has been connected to a SOCKS5 server (requester).

+ *

+ */

+class SOCKS5BytestreamClientSession {

+public:

+ enum State {

+ Initial,

+ Hello,

+ Authenticating,

+ Ready,

+ Writing,

+ Reading,

+ Finished,

+ };

+

+public:

+ typedef boost::shared_ptr<SOCKS5BytestreamClientSession> ref;

+

+public:

+ SOCKS5BytestreamClientSession(boost::shared_ptr<Connection> connection, const HostAddressPort&, const std::string&, TimerFactory*);

+

+ void start();

+ void stop();

+

+ void startReceiving(boost::shared_ptr<WriteBytestream>);

+ void startSending(boost::shared_ptr<ReadBytestream>);

+

+ HostAddressPort getAddressPort() const;

+

+ boost::signal<void (bool /*error*/)> onSessionReady;

+

+ boost::signal<void (boost::optional<FileTransferError>)> onFinished;

+ boost::signal<void (int)> onBytesSent;

+ boost::signal<void (int)> onBytesReceived;

+

+private:

+ void process();

+ void hello();

+ void authenticate();

+

+ void handleConnectFinished(bool error);

+ void handleDataRead(const SafeByteArray&);

+ void handleDisconnected(const boost::optional<Connection::Error>&);

+ void handleWeFailedTimeout();

+

+ void finish(bool error);

+ void sendData();

+

+private:

+ boost::shared_ptr<Connection> connection;

+ HostAddressPort addressPort;

+ std::string destination; // hexify(SHA1(sessionID + requester + target))

+

+ State state;

+ int destinationPort;

+

+ ByteArray unprocessedData;

+ ByteArray authenticateAddress;

+

+ int chunkSize;

+ boost::shared_ptr<WriteBytestream> writeBytestream;

+ boost::shared_ptr<ReadBytestream> readBytestream;

+

+ Timer::ref weFailedTimeout;

+};

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "SOCKS5BytestreamProxy.h"

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/Base/Log.h>

+

+namespace Swift {

+

+SOCKS5BytestreamProxy::SOCKS5BytestreamProxy(ConnectionFactory *connFactory, TimerFactory *timeFactory) : connectionFactory(connFactory), timerFactory(timeFactory) {

+

+}

+

+void SOCKS5BytestreamProxy::addS5BProxy(S5BProxyRequest::ref proxy) {

+ localS5BProxies.push_back(proxy);

+}

+

+const std::vector<S5BProxyRequest::ref>& SOCKS5BytestreamProxy::getS5BProxies() const {

+ return localS5BProxies;

+}

+

+void SOCKS5BytestreamProxy::connectToProxies(const std::string& sessionID) {

+ SWIFT_LOG(debug) << "session ID: " << sessionID << std::endl;

+ ProxyJIDClientSessionMap clientSessions;

+

+ foreach(S5BProxyRequest::ref proxy, localS5BProxies) {

+ boost::shared_ptr<Connection> conn = connectionFactory->createConnection();

+

+ boost::shared_ptr<SOCKS5BytestreamClientSession> session = boost::make_shared<SOCKS5BytestreamClientSession>(conn, proxy->getStreamHost().get().addressPort, sessionID, timerFactory);

+ clientSessions[proxy->getStreamHost().get().jid] = session;

+ session->start();

+ }

+

+ proxySessions[sessionID] = clientSessions;

+}

+

+boost::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxy::getProxySessionAndCloseOthers(const JID& proxyJID, const std::string& sessionID) {

+ // checking parameters

+ if (proxySessions.find(sessionID) == proxySessions.end()) {

+ return boost::shared_ptr<SOCKS5BytestreamClientSession>();

+ }

+ if (proxySessions[sessionID].find(proxyJID) == proxySessions[sessionID].end()) {

+ return boost::shared_ptr<SOCKS5BytestreamClientSession>();

+ }

+

+ // get active session

+ boost::shared_ptr<SOCKS5BytestreamClientSession> activeSession = proxySessions[sessionID][proxyJID];

+ proxySessions[sessionID].erase(proxyJID);

+

+ // close other sessions

+ foreach(const ProxyJIDClientSessionMap::value_type& myPair, proxySessions[sessionID]) {

+ myPair.second->stop();

+ }

+

+ proxySessions.erase(sessionID);

+

+ return activeSession;

+}

+

+boost::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxy::createSOCKS5BytestreamClientSession(HostAddressPort addressPort, const std::string& destAddr) {

+ SOCKS5BytestreamClientSession::ref connection = boost::make_shared<SOCKS5BytestreamClientSession>(connectionFactory->createConnection(), addressPort, destAddr, timerFactory);

+ return connection;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <vector>

+

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Network/ConnectionFactory.h>

+#include <Swiften/Network/TimerFactory.h>

+

+namespace Swift {

+

+/**

+ * - manages list of working S5B proxies

+ * - creates initial connections (for the candidates you provide)

+ */

+class SOCKS5BytestreamProxy {

+public:

+ SOCKS5BytestreamProxy(ConnectionFactory*, TimerFactory*);

+

+ void addS5BProxy(S5BProxyRequest::ref);

+ const std::vector<S5BProxyRequest::ref>& getS5BProxies() const;

+

+ void connectToProxies(const std::string& sessionID);

+ boost::shared_ptr<SOCKS5BytestreamClientSession> getProxySessionAndCloseOthers(const JID& proxyJID, const std::string& sessionID);

+

+ boost::shared_ptr<SOCKS5BytestreamClientSession> createSOCKS5BytestreamClientSession(HostAddressPort addressPort, const std::string& destAddr);

+

+private:

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+

+ typedef std::map<JID, boost::shared_ptr<SOCKS5BytestreamClientSession> > ProxyJIDClientSessionMap;

+ std::map<std::string, ProxyJIDClientSessionMap> proxySessions;

+

+ std::vector<S5BProxyRequest::ref> localS5BProxies;

+};

+

+}

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/StringCodecs/SHA1.h>

+#include <Swiften/StringCodecs/Hexify.h>

+

+void SOCKS5BytestreamRegistry::addReadBytestream(const std::string& destination, boost::shared_ptr<ReadBytestream> byteStream) {

+ readBytestreams[destination] = byteStream;

+void SOCKS5BytestreamRegistry::removeReadBytestream(const std::string& destination) {

+ readBytestreams.erase(destination);

+boost::shared_ptr<ReadBytestream> SOCKS5BytestreamRegistry::getReadBytestream(const std::string& destination) const {

+ ReadBytestreamMap::const_iterator i = readBytestreams.find(destination);

+ if (i != readBytestreams.end()) {

+void SOCKS5BytestreamRegistry::addWriteBytestream(const std::string& destination, boost::shared_ptr<WriteBytestream> byteStream) {

+ writeBytestreams[destination] = byteStream;

+}

+

+void SOCKS5BytestreamRegistry::removeWriteBytestream(const std::string& destination) {

+ writeBytestreams.erase(destination);

+}

+

+boost::shared_ptr<WriteBytestream> SOCKS5BytestreamRegistry::getWriteBytestream(const std::string& destination) const {

+ WriteBytestreamMap::const_iterator i = writeBytestreams.find(destination);

+ if (i != writeBytestreams.end()) {

+ return i->second;

+ }

+ return boost::shared_ptr<WriteBytestream>();

+}

+

+std::string SOCKS5BytestreamRegistry::generateSessionID() {

+ return idGenerator.generateID();

+}

+

+SOCKS5BytestreamServerSession* SOCKS5BytestreamRegistry::getConnectedSession(const std::string& destination) {

+ if (serverSessions.find(destination) != serverSessions.end()) {

+ return serverSessions[destination];

+ } else {

+ SWIFT_LOG(debug) << "No active connction for stream ID " << destination << " found!" << std::endl;

+ return NULL;

+ }

+}

+

+std::string SOCKS5BytestreamRegistry::getHostname(const std::string& sessionID, const JID& requester, const JID& target) {

+ return Hexify::hexify(SHA1::getHash(createSafeByteArray(sessionID + requester.toString() + target.toString())));

+}

+#include <map>

+#include <vector>

+#include <set>

+

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/S5BProxyRequest.h>

+#include <Swiften/FileTransfer/WriteBytestream.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

+#include <Swiften/Network/HostAddressPort.h>

+ boost::shared_ptr<ReadBytestream> getReadBytestream(const std::string& destination) const;

+ void addReadBytestream(const std::string& destination, boost::shared_ptr<ReadBytestream> byteStream);

+ void removeReadBytestream(const std::string& destination);

+

+ boost::shared_ptr<WriteBytestream> getWriteBytestream(const std::string& destination) const;

+ void addWriteBytestream(const std::string& destination, boost::shared_ptr<WriteBytestream> byteStream);

+ void removeWriteBytestream(const std::string& destination);

+

+ /**

+ * Generate a new session ID to use for new S5B streams.

+ */

+ std::string generateSessionID();

+

+ /**

+ * Start an actual transfer.

+ */

+ SOCKS5BytestreamServerSession* getConnectedSession(const std::string& destination);

+

+ public:

+ static std::string getHostname(const std::string& sessionID, const JID& requester, const JID& target);

+ friend class SOCKS5BytestreamServerSession;

+

+ typedef std::map<std::string, boost::shared_ptr<ReadBytestream> > ReadBytestreamMap;

+ ReadBytestreamMap readBytestreams;

+

+ typedef std::map<std::string, boost::shared_ptr<WriteBytestream> > WriteBytestreamMap;

+ WriteBytestreamMap writeBytestreams;

+

+ std::map<std::string, SOCKS5BytestreamServerSession*> serverSessions;

+

+ IDGenerator idGenerator;

+#include <Swiften/Base/Log.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+SOCKS5BytestreamServer::SOCKS5BytestreamServer(boost::shared_ptr<ConnectionServer> connectionServer, SOCKS5BytestreamRegistry* registry) : connectionServer(connectionServer), registry(registry) {

+void SOCKS5BytestreamServer::addReadBytestream(const std::string& id, const JID& from, const JID& to, boost::shared_ptr<ReadBytestream> byteStream) {

+ registry->addReadBytestream(getSOCKSDestinationAddress(id, from, to), byteStream);

+void SOCKS5BytestreamServer::removeReadBytestream(const std::string& id, const JID& from, const JID& to) {

+ registry->removeReadBytestream(getSOCKSDestinationAddress(id, from, to));

+ boost::shared_ptr<SOCKS5BytestreamServerSession> session(new SOCKS5BytestreamServerSession(connection, registry));

+ SOCKS5BytestreamServer(boost::shared_ptr<ConnectionServer> connectionServer, SOCKS5BytestreamRegistry* registry);

+ void addReadBytestream(const std::string& id, const JID& from, const JID& to, boost::shared_ptr<ReadBytestream> byteStream);

+ void removeReadBytestream(const std::string& id, const JID& from, const JID& to);

+ SOCKS5BytestreamRegistry* registry;

+#include <Swiften/Base/Log.h>

+SOCKS5BytestreamServerSession::SOCKS5BytestreamServerSession(boost::shared_ptr<Connection> connection, SOCKS5BytestreamRegistry* bytestreams) : connection(connection), bytestreams(bytestreams), state(Initial), chunkSize(131072) {

+ connection->onDisconnected.connect(boost::bind(&SOCKS5BytestreamServerSession::handleDisconnected, this, _1));

+ SWIFT_LOG(debug) << std::endl;

+ connection->onDataWritten.disconnect(boost::bind(&SOCKS5BytestreamServerSession::sendData, this));

+ connection->onDataRead.disconnect(boost::bind(&SOCKS5BytestreamServerSession::handleDataRead, this, _1));

+ connection->disconnect();

+ state = Finished;

+}

+

+void SOCKS5BytestreamServerSession::startTransfer() {

+ if (state == ReadyForTransfer) {

+ if (readBytestream) {

+ state = WritingData;

+ connection->onDataWritten.connect(boost::bind(&SOCKS5BytestreamServerSession::sendData, this));

+ sendData();

+ }

+ else if(writeBytestream) {

+ state = ReadingData;

+ writeBytestream->write(unprocessedData);

+ onBytesReceived(unprocessedData.size());

+ unprocessedData.clear();

+ }

+ } else {

+ SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl;

+ }

+}

+

+HostAddressPort SOCKS5BytestreamServerSession::getAddressPort() const {

+ return connection->getLocalAddress();

+ if (state != ReadingData) {

+ append(unprocessedData, data);

+ process();

+ } else {

+ writeBytestream->write(createByteArray(data.data(), data.size()));

+ onBytesReceived(data.size());

+ }

+}

+

+void SOCKS5BytestreamServerSession::handleDisconnected(const boost::optional<Connection::Error>& error) {

+ SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl;

+ if (error) {

+ finish(true);

+ }

+ SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;

+ // Skip the port: 2 byte large, one already skipped. Add one for comparison with size

+ if (i <= unprocessedData.size()) {

+ SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;

+ unprocessedData.clear();

+ std::string streamID = byteArrayToString(requestID);

+ readBytestream = bytestreams->getReadBytestream(streamID);

+ writeBytestream = bytestreams->getWriteBytestream(streamID);

+ result.push_back((readBytestream || writeBytestream) ? 0x0 : 0x4);

+ if (!readBytestream && !writeBytestream) {

+ SWIFT_LOG(debug) << "Readstream or Wrtiestream with ID " << streamID << " not found!" << std::endl;

+ SWIFT_LOG(deubg) << "Found " << (readBytestream ? "Readstream" : "Writestream") << ". Sent OK." << std::endl;

+ bytestreams->serverSessions[streamID] = this;

+ state = ReadyForTransfer;

+ if (!readBytestream->isFinished()) {

+ SafeByteArray dataToSend = createSafeByteArray(readBytestream->read(chunkSize));

+ connection->write(dataToSend);

+ onBytesSent(dataToSend.size());

+ connection->onDisconnected.disconnect(boost::bind(&SOCKS5BytestreamServerSession::handleDisconnected, this, _1));

+ readBytestream.reset();

+ if (error) {

+ onFinished(boost::optional<FileTransferError>(FileTransferError::PeerError));

+ } else {

+ onFinished(boost::optional<FileTransferError>());

+ }

+#include <Swiften/FileTransfer/WriteBytestream.h>

+#include <Swiften/FileTransfer/FileTransferError.h>

+ typedef boost::shared_ptr<SOCKS5BytestreamServerSession> ref;

+

+ public:

+ ReadyForTransfer,

+ ReadingData,

+ WritingData,

+ void startTransfer();

+ HostAddressPort getAddressPort() const;

+

+ boost::signal<void (boost::optional<FileTransferError>)> onFinished;

+ boost::signal<void (int)> onBytesSent;

+ boost::signal<void (int)> onBytesReceived;

+ void handleDisconnected(const boost::optional<Connection::Error>&);

+ boost::shared_ptr<ReadBytestream> readBytestream;

+ boost::shared_ptr<WriteBytestream> writeBytestream;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <boost/filesystem.hpp>

+#include <boost/date_time/posix_time/posix_time.hpp>

+

+#include <Swiften/FileTransfer/FileTransferManager.h>

+

+namespace Swift {

+ class DummyFileTransferManager : public FileTransferManager {

+ public:

+ DummyFileTransferManager() : FileTransferManager() {

+ }

+

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID&, const boost::filesystem::path&, const std::string&, boost::shared_ptr<ReadBytestream>) {

+ return OutgoingFileTransfer::ref();

+ }

+

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(const JID&, const std::string&, const std::string&, const boost::uintmax_t, const boost::posix_time::ptime&, boost::shared_ptr<ReadBytestream>) {

+ return OutgoingFileTransfer::ref();

+ }

+

+ virtual void startListeningOnPort(int) {

+ }

+

+ virtual void addS5BProxy(boost::shared_ptr<S5BProxyRequest>) {

+ }

+

+ };

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Elements/IBB.h>

+#include <Swiften/Elements/JingleIBBTransportPayload.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/FileTransfer/ByteArrayWriteBytestream.h>

+#include <Swiften/FileTransfer/IncomingJingleFileTransfer.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+#include <Swiften/Jingle/FakeJingleSession.h>

+#include <Swiften/Network/DummyTimerFactory.h>

+#include <Swiften/EventLoop/DummyEventLoop.h>

+#include <Swiften/Network/DummyConnectionFactory.h>

+#include <Swiften/Network/PlatformNATTraversalWorker.h>

+#include <Swiften/Queries/IQRouter.h>

+

+#include <iostream>

+

+using namespace Swift;

+using namespace boost;

+

+class FakeRemoteJingleTransportCandidateSelector : public RemoteJingleTransportCandidateSelector {

+ void addRemoteTransportCandidates(JingleTransportPayload::ref cand) {

+ candidate = cand;

+ }

+

+ void selectCandidate() {

+ boost::shared_ptr<JingleS5BTransportPayload> payload = make_shared<JingleS5BTransportPayload>();

+ payload->setCandidateError(true);

+ payload->setSessionID(candidate->getSessionID());

+ onRemoteTransportCandidateSelectFinished(payload);

+ }

+

+ void setMinimumPriority(int) {

+

+ }

+

+ bool isActualCandidate(JingleTransportPayload::ref) {

+ return false;

+ }

+

+ int getPriority(JingleTransportPayload::ref) {

+ return 0;

+ }

+

+ JingleTransport::ref selectTransport(JingleTransportPayload::ref) {

+ return JingleTransport::ref();

+ }

+

+private:

+ JingleTransportPayload::ref candidate;

+};

+

+class FakeRemoteJingleTransportCandidateSelectorFactory : public RemoteJingleTransportCandidateSelectorFactory {

+public:

+ virtual ~FakeRemoteJingleTransportCandidateSelectorFactory() {

+

+ }

+

+ virtual RemoteJingleTransportCandidateSelector* createCandidateSelector() {

+ return new FakeRemoteJingleTransportCandidateSelector();

+ }

+};

+

+class FakeLocalJingleTransportCandidateGenerator : public LocalJingleTransportCandidateGenerator {

+public:

+ virtual void generateLocalTransportCandidates(JingleTransportPayload::ref payload) {

+ JingleS5BTransportPayload::ref payL = make_shared<JingleS5BTransportPayload>();

+ payL->setSessionID(payload->getSessionID());

+ onLocalTransportCandidatesGenerated(payL);

+ }

+

+ void emitonLocalTransportCandidatesGenerated(JingleTransportPayload::ref payload) {

+ onLocalTransportCandidatesGenerated(payload);

+ }

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref) {

+ return false;

+ }

+

+ virtual int getPriority(JingleTransportPayload::ref) {

+ return 0;

+ }

+

+ virtual JingleTransport::ref selectTransport(JingleTransportPayload::ref) {

+ return JingleTransport::ref();

+ }

+};

+

+class FakeLocalJingleTransportCandidateGeneratorFactory : public LocalJingleTransportCandidateGeneratorFactory {

+public:

+ virtual LocalJingleTransportCandidateGenerator* createCandidateGenerator() {

+ return new FakeLocalJingleTransportCandidateGenerator();

+ }

+};

+

+class IncomingJingleFileTransferTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(IncomingJingleFileTransferTest);

+ CPPUNIT_TEST(test_AcceptOnyIBBSendsSessionAccept);

+ CPPUNIT_TEST(test_OnlyIBBTransferReceiveWorks);

+ CPPUNIT_TEST(test_AcceptFailingS5BFallsBackToIBB);

+ CPPUNIT_TEST_SUITE_END();

+public:

+ shared_ptr<IncomingJingleFileTransfer> createTestling() {

+ JID ourJID("our@jid.org/full");

+ return make_shared<IncomingJingleFileTransfer>(ourJID, shared_ptr<JingleSession>(fakeJingleSession), jingleContentPayload, fakeRJTCSF.get(), fakeLJTCF.get(), iqRouter, bytestreamRegistry, bytestreamProxy, timerFactory);

+ }

+

+ IQ::ref createIBBRequest(IBB::ref ibb, const JID& from, const std::string& id) {

+ IQ::ref request = IQ::createRequest(IQ::Set, JID("foo@bar.com/baz"), id, ibb);

+ request->setFrom(from);

+ return request;

+ }

+

+ void setUp() {

+ eventLoop = new DummyEventLoop();

+ fakeJingleSession = new FakeJingleSession("foo@bar.com/baz", "mysession");

+ jingleContentPayload = make_shared<JingleContentPayload>();

+ fakeRJTCSF = make_shared<FakeRemoteJingleTransportCandidateSelectorFactory>();

+ fakeLJTCF = make_shared<FakeLocalJingleTransportCandidateGeneratorFactory>();

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ bytestreamRegistry = new SOCKS5BytestreamRegistry();

+ timerFactory = new DummyTimerFactory();

+ connectionFactory = new DummyConnectionFactory(eventLoop);

+ bytestreamProxy = new SOCKS5BytestreamProxy(connectionFactory, timerFactory);

+ }

+

+ void tearDown() {

+ delete bytestreamProxy;

+ delete connectionFactory;

+ delete timerFactory;

+ delete bytestreamRegistry;

+ delete iqRouter;

+ delete stanzaChannel;

+ delete eventLoop;

+ }

+

+ // Tests whether IncomingJingleFileTransfer would accept a IBB only file transfer.

+ void test_AcceptOnyIBBSendsSessionAccept() {

+ //1. create your test incoming file transfer

+ shared_ptr<JingleFileTransferDescription> desc = make_shared<JingleFileTransferDescription>();

+ desc->addOffer(StreamInitiationFileInfo());

+ jingleContentPayload->addDescription(desc);

+ JingleIBBTransportPayload::ref tpRef = make_shared<JingleIBBTransportPayload>();

+ tpRef->setSessionID("mysession");

+ jingleContentPayload->addTransport(tpRef);

+

+ shared_ptr<IncomingJingleFileTransfer> fileTransfer = createTestling();

+

+ //2. do 'accept' on a dummy writebytestream (you'll have to look if there already is one)

+ shared_ptr<ByteArrayWriteBytestream> byteStream = make_shared<ByteArrayWriteBytestream>();

+ fileTransfer->accept(byteStream);

+

+ // check whether accept has been called

+ getCall<FakeJingleSession::AcceptCall>(0);

+ }

+

+ void test_OnlyIBBTransferReceiveWorks() {

+ //1. create your test incoming file transfer

+ shared_ptr<JingleFileTransferDescription> desc = make_shared<JingleFileTransferDescription>();

+ desc->addOffer(StreamInitiationFileInfo());

+ jingleContentPayload->addDescription(desc);

+ JingleIBBTransportPayload::ref tpRef = make_shared<JingleIBBTransportPayload>();

+ tpRef->setSessionID("mysession");

+ jingleContentPayload->addTransport(tpRef);

+

+ shared_ptr<IncomingJingleFileTransfer> fileTransfer = createTestling();

+

+ //2. do 'accept' on a dummy writebytestream (you'll have to look if there already is one)

+ shared_ptr<ByteArrayWriteBytestream> byteStream = make_shared<ByteArrayWriteBytestream>();

+ fileTransfer->accept(byteStream);

+

+ // check whether accept has been called

+ getCall<FakeJingleSession::AcceptCall>(0);

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ CPPUNIT_ASSERT(createByteArray("abc") == byteStream->getData());

+ }

+

+ void test_AcceptFailingS5BFallsBackToIBB() {

+ //1. create your test incoming file transfer

+ addFileTransferDescription();

+

+ // add SOCKS5BytestreamTransportPayload

+ JingleS5BTransportPayload::ref payLoad = addJingleS5BPayload();

+

+ shared_ptr<IncomingJingleFileTransfer> fileTransfer = createTestling();

+

+ //2. do 'accept' on a dummy writebytestream (you'll have to look if there already is one)

+ shared_ptr<ByteArrayWriteBytestream> byteStream = make_shared<ByteArrayWriteBytestream>();

+ fileTransfer->accept(byteStream);

+

+ // check whether accept has been called

+ FakeJingleSession::AcceptCall acceptCall = getCall<FakeJingleSession::AcceptCall>(0);

+ CPPUNIT_ASSERT_EQUAL(payLoad->getSessionID(), acceptCall.payload->getSessionID());

+

+ // check for candidate error

+ FakeJingleSession::InfoTransportCall infoTransportCall = getCall<FakeJingleSession::InfoTransportCall>(1);

+ JingleS5BTransportPayload::ref s5bPayload = dynamic_pointer_cast<JingleS5BTransportPayload>(infoTransportCall.payload);

+ CPPUNIT_ASSERT(s5bPayload->hasCandidateError());

+

+ // indicate transport replace (Romeo)

+ fakeJingleSession->onTransportReplaceReceived(getContentID(), addJingleIBBPayload());

+

+ FakeJingleSession::AcceptTransportCall acceptTransportCall = getCall<FakeJingleSession::AcceptTransportCall>(2);

+

+ // send a bit of data

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, createByteArray("abc")), "foo@bar.com/baz", "id-a"));

+ CPPUNIT_ASSERT(createByteArray("abc") == byteStream->getData());

+ }

+

+ void test_S5BTransferReceiveTest() {

+ addFileTransferDescription();

+ JingleS5BTransportPayload::ref payLoad = addJingleS5BPayload();

+ }

+

+private:

+ void addFileTransferDescription() {

+ shared_ptr<JingleFileTransferDescription> desc = make_shared<JingleFileTransferDescription>();

+ desc->addOffer(StreamInitiationFileInfo());

+ jingleContentPayload->addDescription(desc);

+ }

+

+ shared_ptr<JingleS5BTransportPayload> addJingleS5BPayload() {

+ JingleS5BTransportPayload::ref payLoad = make_shared<JingleS5BTransportPayload>();

+ payLoad->setSessionID("mysession");

+ jingleContentPayload->addTransport(payLoad);

+ return payLoad;

+ }

+

+ shared_ptr<JingleIBBTransportPayload> addJingleIBBPayload() {

+ JingleIBBTransportPayload::ref payLoad = make_shared<JingleIBBTransportPayload>();

+ payLoad->setSessionID("mysession");

+ jingleContentPayload->addTransport(payLoad);

+ return payLoad;

+ }

+

+ JingleContentID getContentID() const {

+ return JingleContentID(jingleContentPayload->getName(), jingleContentPayload->getCreator());

+ }

+

+ template <typename T> T getCall(int i) const {

+ size_t index = static_cast<size_t>(i);

+ CPPUNIT_ASSERT(index < fakeJingleSession->calledCommands.size());

+ T* cmd = boost::get<T>(&fakeJingleSession->calledCommands[index]);

+ CPPUNIT_ASSERT(cmd);

+ return *cmd;

+ }

+

+private:

+ EventLoop* eventLoop;

+ FakeJingleSession* fakeJingleSession;

+ shared_ptr<JingleContentPayload> jingleContentPayload;

+ shared_ptr<FakeRemoteJingleTransportCandidateSelectorFactory> fakeRJTCSF;

+ shared_ptr<FakeLocalJingleTransportCandidateGeneratorFactory> fakeLJTCF;

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+ DummyConnectionFactory* connectionFactory;

+ SOCKS5BytestreamProxy* bytestreamProxy;

+ DummyTimerFactory* timerFactory;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(IncomingJingleFileTransferTest);

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <boost/bind.hpp>

+#include <boost/optional.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

+#include <Swiften/Jingle/FakeJingleSession.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelectorFactory.h>

+#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGeneratorFactory.h>

+#include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>

+#include <Swiften/Queries/IQRouter.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/FileTransfer/ByteArrayReadBytestream.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

+#include <Swiften/FileTransfer/SOCKS5BytestreamProxy.h>

+

+#include <Swiften/Elements/JingleIBBTransportPayload.h>

+#include <Swiften/Elements/JingleS5BTransportPayload.h>

+#include <Swiften/Elements/JingleFileTransferDescription.h>

+#include <Swiften/Elements/IBB.h>

+#include <Swiften/Base/ByteArray.h>

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/EventLoop/DummyEventLoop.h>

+#include <Swiften/Network/PlatformNATTraversalWorker.h>

+#include <Swiften/Network/DummyTimerFactory.h>

+#include <Swiften/Network/DummyConnection.h>

+#include <Swiften/Network/ConnectionFactory.h>

+#include <Swiften/Network/DummyConnectionFactory.h>

+

+#include <Swiften/Base/Log.h>

+

+#include <iostream>

+

+using namespace Swift;

+

+class OFakeRemoteJingleTransportCandidateSelector : public RemoteJingleTransportCandidateSelector {

+ void addRemoteTransportCandidates(JingleTransportPayload::ref cand) {

+ candidate = cand;

+ }

+

+ void selectCandidate() {

+ JingleS5BTransportPayload::ref payload = boost::make_shared<JingleS5BTransportPayload>();

+ payload->setCandidateError(true);

+ payload->setSessionID(candidate->getSessionID());

+ onRemoteTransportCandidateSelectFinished(payload);

+ }

+

+ void setMinimumPriority(int) {

+

+ }

+

+ bool isActualCandidate(JingleTransportPayload::ref) {

+ return false;

+ }

+

+ int getPriority(JingleTransportPayload::ref) {

+ return 0;

+ }

+

+ JingleTransport::ref selectTransport(JingleTransportPayload::ref) {

+ return JingleTransport::ref();

+ }

+

+private:

+ JingleTransportPayload::ref candidate;

+};

+

+class OFakeRemoteJingleTransportCandidateSelectorFactory : public RemoteJingleTransportCandidateSelectorFactory {

+public:

+ virtual ~OFakeRemoteJingleTransportCandidateSelectorFactory() {

+

+ }

+

+ virtual RemoteJingleTransportCandidateSelector* createCandidateSelector() {

+ return new OFakeRemoteJingleTransportCandidateSelector();

+ }

+};

+

+class OFakeLocalJingleTransportCandidateGenerator : public LocalJingleTransportCandidateGenerator {

+public:

+ virtual void generateLocalTransportCandidates(JingleTransportPayload::ref /* payload */) {

+ //JingleTransportPayload::ref payL = make_shared<JingleTransportPayload>();

+ //payL->setSessionID(payload->getSessionID());

+ JingleS5BTransportPayload::ref payL = boost::make_shared<JingleS5BTransportPayload>();

+

+ onLocalTransportCandidatesGenerated(payL);

+ }

+

+ void emitonLocalTransportCandidatesGenerated(JingleTransportPayload::ref payload) {

+ onLocalTransportCandidatesGenerated(payload);

+ }

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref) {

+ return false;

+ }

+

+ virtual int getPriority(JingleTransportPayload::ref) {

+ return 0;

+ }

+

+ virtual JingleTransport::ref selectTransport(JingleTransportPayload::ref) {

+ return JingleTransport::ref();

+ }

+};

+

+class OFakeLocalJingleTransportCandidateGeneratorFactory : public LocalJingleTransportCandidateGeneratorFactory {

+public:

+ virtual LocalJingleTransportCandidateGenerator* createCandidateGenerator() {

+ return new OFakeLocalJingleTransportCandidateGenerator();

+ }

+};

+

+class OutgoingJingleFileTransferTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(OutgoingJingleFileTransferTest);

+ CPPUNIT_TEST(test_SendSessionInitiateOnStart);

+ CPPUNIT_TEST(test_IBBStartsAfterSendingSessionAccept);

+ CPPUNIT_TEST(test_ReceiveSessionTerminateAfterSessionInitiate);

+ CPPUNIT_TEST_SUITE_END();

+

+ class FTStatusHelper {

+ public:

+ bool finishedCalled;

+ FileTransferError::Type error;

+ void handleFileTransferFinished(boost::optional<FileTransferError> error) {

+ finishedCalled = true;

+ if (error.is_initialized()) this->error = error.get().getType();

+ }

+ };

+public:

+

+ boost::shared_ptr<OutgoingJingleFileTransfer> createTestling() {

+ JID to("test@foo.com/bla");

+ StreamInitiationFileInfo fileInfo;

+ fileInfo.setDescription("some file");

+ fileInfo.setName("test.bin");

+ fileInfo.setHash("asdjasdas");

+ fileInfo.setSize(1024 * 1024);

+ return boost::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(boost::shared_ptr<JingleSession>(fakeJingleSession), fakeRJTCSF.get(), fakeLJTCF.get(), iqRouter, idGen, to, stream, fileInfo, s5bRegistry, s5bProxy));

+ }

+

+ IQ::ref createIBBRequest(IBB::ref ibb, const JID& from, const std::string& id) {

+ IQ::ref request = IQ::createRequest(IQ::Set, JID("foo@bar.com/baz"), id, ibb);

+ request->setFrom(from);

+ return request;

+ }

+

+ void setUp() {

+ fakeJingleSession = new FakeJingleSession("foo@bar.com/baz", "mysession");

+ jingleContentPayload = boost::make_shared<JingleContentPayload>();

+ fakeRJTCSF = boost::make_shared<OFakeRemoteJingleTransportCandidateSelectorFactory>();

+ fakeLJTCF = boost::make_shared<OFakeLocalJingleTransportCandidateGeneratorFactory>();

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ eventLoop = new DummyEventLoop();

+ timerFactory = new DummyTimerFactory();

+ connectionFactory = new DummyConnectionFactory(eventLoop);

+ s5bRegistry = new SOCKS5BytestreamRegistry();

+ s5bProxy = new SOCKS5BytestreamProxy(connectionFactory, timerFactory);

+

+ data.clear();

+ for (int n=0; n < 1024 * 1024; ++n) {

+ data.push_back(34);

+ }

+

+ stream = boost::make_shared<ByteArrayReadBytestream>(data);

+

+ idGen = new IDGenerator();

+ }

+

+ void tearDown() {

+ delete idGen;

+ delete s5bRegistry;

+ delete connectionFactory;

+ delete timerFactory;

+ delete eventLoop;

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+

+ void test_SendSessionInitiateOnStart() {

+ boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

+ transfer->start();