+ void clear() {

+ data_.clear();

+ }

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+ template<typename T> class StartStopper {

+ public:

+ StartStopper(T* target) : target(target) {

+ target->start();

+ }

+

+ ~StartStopper() {

+ target->stop();

+ }

+

+ private:

+ T* target;

+ };

+}

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+#include <boost/optional.hpp>

+

+#include "Swiften/JID/JID.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/Shared.h"

+#include "Swiften/Elements/Payload.h"

+

+namespace Swift {

+ class Bytestreams : public Payload, public Shared<Bytestreams> {

+ public:

+ struct StreamHost {

+ StreamHost(const String& host = "", const JID& jid = JID(), int port = -1) : host(host), jid(jid), port(port) {}

+

+ String host;

+ JID jid;

+ int port;

+ };

+

+ Bytestreams() {}

+

+ const String& getStreamID() const {

+ return id;

+ }

+

+ void setStreamID(const String& id) {

+ this->id = id;

+ }

+

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

+ return usedStreamHost;

+ }

+

+ void setUsedStreamHost(const JID& host) {

+ usedStreamHost = host;

+ }

+

+ const std::vector<StreamHost>& getStreamHosts() const {

+ return streamHosts;

+ }

+

+ void addStreamHost(const StreamHost& streamHost) {

+ streamHosts.push_back(streamHost);

+ }

+

+ private:

+ String id;

+ boost::optional<JID> usedStreamHost;

+ std::vector<StreamHost> streamHosts;

+ };

+}

+ FormField::ref field = getField("FORM_TYPE");

+ boost::shared_ptr<HiddenFormField> f = boost::dynamic_pointer_cast<HiddenFormField>(field);

+ return (f ? f->getValue() : "");

+}

+

+FormField::ref Form::getField(const String& name) const {

+ if (field->getName() == name) {

+ return field;

+ return FormField::ref();

+

+ FormField::ref getField(const String& name) const;

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/Shared.h"

+#include "Swiften/Base/ByteArray.h"

+#include "Swiften/Elements/Payload.h"

+

+namespace Swift {

+ class IBB : public Payload, public Shared<IBB> {

+ public:

+ enum Action {

+ Open,

+ Close,

+ Data,

+ };

+ enum StanzaType {

+ IQStanza,

+ MessageStanza,

+ };

+

+ IBB(Action action = Open, const String& streamID = "") : action(action), streamID(streamID), stanzaType(IQStanza), blockSize(-1), sequenceNumber(-1) {

+ }

+

+ static IBB::ref createIBBOpen(const String& streamID, int blockSize) {

+ IBB::ref result(new IBB(Open, streamID));

+ result->setBlockSize(blockSize);

+ return result;

+ }

+

+ static IBB::ref createIBBData(const String& streamID, int sequenceNumber, const ByteArray& data) {

+ IBB::ref result(new IBB(Data, streamID));

+ result->setSequenceNumber(sequenceNumber);

+ result->setData(data);

+ return result;

+ }

+

+ static IBB::ref createIBBClose(const String& streamID) {

+ return IBB::ref(new IBB(Close, streamID));

+ }

+

+ void setAction(Action action) {

+ this->action = action;

+ }

+

+ Action getAction() const {

+ return action;

+ }

+

+ void setStanzaType(StanzaType stanzaType) {

+ this->stanzaType = stanzaType;

+ }

+

+ StanzaType getStanzaType() const {

+ return stanzaType;

+ }

+

+ void setStreamID(const String& id) {

+ streamID = id;

+ }

+

+ const String& getStreamID() const {

+ return streamID;

+ }

+

+ const ByteArray& getData() const {

+ return data;

+ }

+

+ void setData(const ByteArray& data) {

+ this->data = data;

+ }

+

+ int getBlockSize() const {

+ return blockSize;

+ }

+

+ void setBlockSize(int blockSize) {

+ this->blockSize = blockSize;

+ }

+

+ int getSequenceNumber() const {

+ return sequenceNumber;

+ }

+

+ void setSequenceNumber(int i) {

+ sequenceNumber = i;

+ }

+

+ private:

+ Action action;

+ String streamID;

+ ByteArray data;

+ StanzaType stanzaType;

+ int blockSize;

+ int sequenceNumber;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+#include <boost/optional.hpp>

+

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/Shared.h"

+#include "Swiften/Elements/Payload.h"

+

+namespace Swift {

+ class StreamInitiation : public Payload, public Shared<StreamInitiation> {

+ public:

+ struct FileInfo {

+ FileInfo(const String& name = "", const String& description = "", int size = -1) : name(name), description(description), size(size) {}

+

+ String name;

+ String description;

+ int size;

+ };

+

+ StreamInitiation() : isFileTransfer(true) {}

+

+ const String& getID() const {

+ return id;

+ }

+

+ void setID(const String& id) {

+ this->id = id;

+ }

+

+ const boost::optional<FileInfo>& getFileInfo() const {

+ return fileInfo;

+ }

+

+ void setFileInfo(const FileInfo& info) {

+ fileInfo = info;

+ }

+

+ const std::vector<String>& getProvidedMethods() const {

+ return providedMethods;

+ }

+

+ void addProvidedMethod(const String& method) {

+ providedMethods.push_back(method);

+ }

+

+ void setRequestedMethod(const String& method) {

+ requestedMethod = method;

+ }

+

+ const String& getRequestedMethod() const {

+ return requestedMethod;

+ }

+

+ bool getIsFileTransfer() const {

+ return isFileTransfer;

+ }

+

+ void setIsFileTransfer(bool b) {

+ isFileTransfer = b;

+ }

+

+ private:

+ bool isFileTransfer;

+ String id;

+ boost::optional<FileInfo> fileInfo;

+ std::vector<String> providedMethods;

+ String requestedMethod;

+ };

+}

+ CPPUNIT_TEST(testGetFormType_InvalidFormType);

+ CPPUNIT_TEST(testGetFormType_NoFormType);

+

+ void testGetFormType_InvalidFormType() {

+ Form form;

+

+ FormField::ref field = FixedFormField::create("jabber:bot");

+ field->setName("FORM_TYPE");

+ form.addField(field);

+

+ CPPUNIT_ASSERT_EQUAL(String(""), form.getFormType());

+ }

+

+ void testGetFormType_NoFormType() {

+ Form form;

+

+ form.addField(FixedFormField::create("Foo"));

+

+ CPPUNIT_ASSERT_EQUAL(String(""), form.getFormType());

+ }

+ "SendFile",

+SendFile

+Import("env")

+

+myenv = env.Clone()

+myenv.MergeFlags(myenv["SWIFTEN_FLAGS"])

+myenv.MergeFlags(myenv["LIBIDN_FLAGS"])

+myenv.MergeFlags(myenv["BOOST_FLAGS"])

+myenv.MergeFlags(myenv["ZLIB_FLAGS"])

+myenv.MergeFlags(myenv["OPENSSL_FLAGS"])

+myenv.MergeFlags(myenv.get("SQLITE_FLAGS", {}))

+myenv.MergeFlags(myenv.get("LIBXML_FLAGS", ""))

+myenv.MergeFlags(myenv.get("EXPAT_FLAGS", ""))

+myenv.MergeFlags(myenv["PLATFORM_FLAGS"])

+tester = myenv.Program("SendFile", ["SendFile.cpp"])

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <boost/bind.hpp>

+#include <boost/filesystem.hpp>

+

+#include "Swiften/Client/Client.h"

+#include "Swiften/Network/BoostTimer.h"

+#include "Swiften/EventLoop/MainEventLoop.h"

+#include "Swiften/Client/ClientXMLTracer.h"

+#include "Swiften/EventLoop/SimpleEventLoop.h"

+#include "Swiften/Network/MainBoostIOServiceThread.h"

+#include "Swiften/FileTransfer/OutgoingFileTransfer.h"

+#include "Swiften/FileTransfer/FileReadBytestream.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamServer.h"

+#include "Swiften/Network/BoostConnectionServer.h"

+#include "Swiften/Network/BoostIOServiceThread.h"

+

+using namespace Swift;

+

+SimpleEventLoop eventLoop;

+int exitCode = 2;

+

+class FileSender {

+ public:

+ FileSender(const JID& jid, const String& password, const JID& recipient, const boost::filesystem::path& file, int port) : jid(jid), password(password), recipient(recipient), file(file), transfer(NULL) {

+ connectionServer = BoostConnectionServer::create(port, &MainBoostIOServiceThread::getInstance().getIOService());

+ socksBytestreamServer = new SOCKS5BytestreamServer(connectionServer);

+

+ client = new Swift::Client(jid, password);

+ client->onConnected.connect(boost::bind(&FileSender::handleConnected, this));

+ client->onError.connect(boost::bind(&FileSender::handleError, this, _1));

+ //tracer = new ClientXMLTracer(client);

+ }

+

+ ~FileSender() {

+ //delete tracer;

+ client->onError.disconnect(boost::bind(&FileSender::handleError, this, _1));

+ client->onConnected.disconnect(boost::bind(&FileSender::handleConnected, this));

+ delete client;

+ delete socksBytestreamServer;

+ }

+

+ void start() {

+ connectionServer->start();

+ socksBytestreamServer->start();

+ client->connect();

+ }

+

+ void stop() {

+ if (transfer) {

+ transfer->stop();

+ }

+ client->disconnect();

+ socksBytestreamServer->stop();

+ connectionServer->stop();

+ }

+

+ private:

+ void handleConnected() {

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

+ transfer = new OutgoingFileTransfer("myid", client->getJID(), recipient, file.filename(), boost::filesystem::file_size(file), "A file", boost::shared_ptr<FileReadBytestream>(new FileReadBytestream(file)), client->getIQRouter(), socksBytestreamServer);

+ transfer->onFinished.connect(boost::bind(&FileSender::handleFileTransferFinished, this, _1));

+ transfer->start();

+ }

+

+ void handleError(const ClientError&) {

+ std::cerr << "Error!" << std::endl;

+ exit(-1);

+ }

+

+ void handleFileTransferFinished(const boost::optional<FileTransferError>& error) {

+ std::cout << "File transfer finished" << std::endl;

+ if (error) {

+ exit(-1);

+ }

+ else {

+ exit(0);

+ }

+ }

+

+ void exit(int code) {

+ exitCode = code;

+ stop();

+ eventLoop.stop();

+ }

+

+ private:

+ BoostConnectionServer::ref connectionServer;

+ SOCKS5BytestreamServer* socksBytestreamServer;

+ JID jid;

+ String password;

+ JID recipient;

+ boost::filesystem::path file;

+ Client* client;

+ ClientXMLTracer* tracer;

+ OutgoingFileTransfer* transfer;

+};

+

+

+int main(int argc, char* argv[]) {

+ if (argc != 5) {

+ std::cerr << "Usage: " << argv[0] << " <jid> <password> <recipient> <file>" << std::endl;

+ return -1;

+ }

+

+ JID sender(argv[1]);

+ JID recipient(argv[3]);

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

+ fileSender.start();

+

+ {

+ /*BoostTimer::ref timer(BoostTimer::create(30000, &MainBoostIOServiceThread::getInstance().getIOService()));

+ timer->onTick.connect(boost::bind(&SimpleEventLoop::stop, &eventLoop));

+ timer->start();*/

+

+ eventLoop.run();

+ }

+

+ return exitCode;

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/FileTransfer/ReadBytestream.h"

+#include "Swiften/Base/ByteArray.h"

+

+namespace Swift {

+ class ByteArrayReadBytestream : public ReadBytestream {

+ public:

+ ByteArrayReadBytestream(const ByteArray& data) : data(data), position(0) {

+ }

+

+ virtual ByteArray read(size_t size) {

+ size_t readSize = size;

+ if (position + readSize > data.getSize()) {

+ readSize = data.getSize() - position;

+ }

+ ByteArray result(data.getData() + position, readSize);

+ position += readSize;

+ return result;

+ }

+

+ virtual bool isFinished() const {

+ return position >= data.getSize();

+ }

+

+ private:

+ ByteArray data;

+ size_t position;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <stdexcept>

+

+namespace Swift {

+ class BytestreamException : public std::exception {

+ public:

+ BytestreamException() {

+ }

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Queries/GenericRequest.h"

+#include "Swiften/Elements/Bytestreams.h"

+#include "Swiften/Base/Shared.h"

+

+namespace Swift {

+ class BytestreamsRequest : public GenericRequest<Bytestreams>, public Shared<BytestreamsRequest> {

+ public:

+ static ref create(const JID& jid, boost::shared_ptr<Bytestreams> payload, IQRouter* router) {

+ return ref(new BytestreamsRequest(jid, payload, router));

+ }

+

+ private:

+ BytestreamsRequest(const JID& jid, boost::shared_ptr<Bytestreams> payload, IQRouter* router) : GenericRequest<Bytestreams>(IQ::Set, jid, payload, router) {

+ }

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <boost/filesystem/fstream.hpp>

+#include <cassert>

+

+#include "Swiften/FileTransfer/FileReadBytestream.h"

+

+namespace Swift {

+

+FileReadBytestream::FileReadBytestream(const boost::filesystem::path& file) : file(file), stream(NULL) {

+}

+

+FileReadBytestream::~FileReadBytestream() {

+ if (stream) {

+ stream->close();

+ stream = NULL;

+ }

+}

+

+ByteArray FileReadBytestream::read(size_t size) {

+ if (!stream) {

+ stream = new boost::filesystem::ifstream(file, std::ios_base::in|std::ios_base::binary);

+ }

+ ByteArray result;

+ result.resize(size);

+ assert(stream->good());

+ stream->read(result.getData(), size);

+ result.resize(stream->gcount());

+ return result;

+}

+

+bool FileReadBytestream::isFinished() const {

+ return stream && !stream->good();

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/filesystem.hpp>

+#include <boost/filesystem/fstream.hpp>

+

+#include "Swiften/FileTransfer/ReadBytestream.h"

+

+namespace Swift {

+ class FileReadBytestream : public ReadBytestream {

+ public:

+ FileReadBytestream(const boost::filesystem::path& file);

+ ~FileReadBytestream();

+

+ virtual ByteArray read(size_t size) ;

+ virtual bool isFinished() const;

+

+ private:

+ boost::filesystem::path file;

+ boost::filesystem::ifstream* stream;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+ class FileTransferError {

+ public:

+ enum Type {

+ UnknownError,

+ PeerError,

+ ReadError,

+ };

+

+ FileTransferError(Type type = UnknownError) : type(type) {}

+

+ Type getType() const {

+ return type;

+ }

+

+ private:

+ Type type;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Queries/GenericRequest.h"

+#include "Swiften/Elements/IBB.h"

+#include "Swiften/Base/Shared.h"

+

+namespace Swift {

+ class IBBRequest : public GenericRequest<IBB>, public Shared<IBBRequest> {

+ public:

+ static ref create(const JID& jid, boost::shared_ptr<IBB> payload, IQRouter* router) {

+ return ref(new IBBRequest(jid, payload, router));

+ }

+

+ private:

+ IBBRequest(const JID& jid, boost::shared_ptr<IBB> payload, IQRouter* router) : GenericRequest<IBB>(IQ::Set, jid, payload, router) {

+ }

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/IBBSendSession.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Queries/IQRouter.h"

+#include "Swiften/FileTransfer/IBBRequest.h"

+#include "Swiften/FileTransfer/BytestreamException.h"

+

+namespace Swift {

+

+IBBSendSession::IBBSendSession(const String& id, const JID& to, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* router) : id(id), to(to), bytestream(bytestream), router(router), blockSize(4096), sequenceNumber(0), active(false) {

+}

+

+IBBSendSession::~IBBSendSession() {

+}

+

+void IBBSendSession::start() {

+ IBBRequest::ref request = IBBRequest::create(to, IBB::createIBBOpen(id, blockSize), router);

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

+ active = true;

+ request->send();

+}

+

+void IBBSendSession::stop() {

+ if (active && router->isAvailable()) {

+ IBBRequest::create(to, IBB::createIBBClose(id), router)->send();

+ }

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

+}

+

+void IBBSendSession::handleIBBResponse(IBB::ref, const boost::optional<ErrorPayload>& error) {

+ if (!error) {

+ if (!bytestream->isFinished()) {

+ try {

+ ByteArray data = bytestream->read(blockSize);

+ IBBRequest::ref request = IBBRequest::create(to, IBB::createIBBData(id, sequenceNumber, data), router);

+ sequenceNumber++;

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

+ request->send();

+ }

+ catch (const BytestreamException& e) {

+ finish(FileTransferError(FileTransferError::ReadError));

+ }

+ }

+ else {

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

+ }

+ }

+ else {

+ finish(FileTransferError(FileTransferError::PeerError));

+ }

+}

+

+void IBBSendSession::finish(boost::optional<FileTransferError> error) {

+ active = false;

+ onFinished(error);

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <boost/optional.hpp>

+

+#include "Swiften/Base/boost_bsignals.h"

+#include "Swiften/FileTransfer/ReadBytestream.h"

+#include "Swiften/JID/JID.h"

+#include "Swiften/Elements/IBB.h"

+#include "Swiften/Elements/ErrorPayload.h"

+#include "Swiften/FileTransfer/FileTransferError.h"

+

+namespace Swift {

+ class IQRouter;

+

+ class IBBSendSession {

+ public:

+ IBBSendSession(const String& id, const JID& to, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* router);

+ ~IBBSendSession();

+

+ void start();

+ void stop();

+

+ void setBlockSize(int blockSize) {

+ this->blockSize = blockSize;

+ }

+

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

+

+ private:

+ void handleIBBResponse(IBB::ref, const boost::optional<ErrorPayload>&);

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

+

+ private:

+ String id;

+ JID to;

+ boost::shared_ptr<ReadBytestream> bytestream;

+ IQRouter* router;

+ int blockSize;

+ int sequenceNumber;

+ bool active;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/OutgoingFileTransfer.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/FileTransfer/StreamInitiationRequest.h"

+#include "Swiften/FileTransfer/BytestreamsRequest.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamServer.h"

+#include "Swiften/FileTransfer/IBBSendSession.h"

+

+namespace Swift {

+

+OutgoingFileTransfer::OutgoingFileTransfer(const String& id, const JID& from, const JID& to, const String& name, int size, const String& description, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer) : id(id), from(from), to(to), name(name), size(size), description(description), bytestream(bytestream), iqRouter(iqRouter), socksServer(socksServer) {

+}

+

+void OutgoingFileTransfer::start() {

+ StreamInitiation::ref streamInitiation(new StreamInitiation());

+ streamInitiation->setID(id);

+ streamInitiation->setFileInfo(StreamInitiation::FileInfo(name, description, size));

+ //streamInitiation->addProvidedMethod("http://jabber.org/protocol/bytestreams");

+ streamInitiation->addProvidedMethod("http://jabber.org/protocol/ibb");

+ StreamInitiationRequest::ref request = StreamInitiationRequest::create(to, streamInitiation, iqRouter);

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

+ request->send();

+}

+

+void OutgoingFileTransfer::stop() {

+}

+

+void OutgoingFileTransfer::handleStreamInitiationRequestResponse(StreamInitiation::ref response, const boost::optional<ErrorPayload>& error) {

+ if (error) {

+ finish(FileTransferError());

+ }

+ else {

+ if (response->getRequestedMethod() == "http://jabber.org/protocol/bytestreams") {

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

+ Bytestreams::ref bytestreams(new Bytestreams());

+ bytestreams->setStreamID(id);

+ HostAddressPort addressPort = socksServer->getAddressPort();

+ bytestreams->addStreamHost(Bytestreams::StreamHost(addressPort.getAddress().toString(), from, addressPort.getPort()));

+ BytestreamsRequest::ref request = BytestreamsRequest::create(to, bytestreams, iqRouter);

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

+ request->send();

+ }

+ else if (response->getRequestedMethod() == "http://jabber.org/protocol/ibb") {

+ ibbSession = boost::shared_ptr<IBBSendSession>(new IBBSendSession(id, to, bytestream, iqRouter));

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

+ ibbSession->start();

+ }

+ }

+}

+

+void OutgoingFileTransfer::handleBytestreamsRequestResponse(Bytestreams::ref, const boost::optional<ErrorPayload>& error) {

+ if (error) {

+ finish(FileTransferError());

+ }

+ //socksServer->onTransferFinished.connect();

+}

+

+void OutgoingFileTransfer::finish(boost::optional<FileTransferError> error) {

+ if (ibbSession) {

+ ibbSession->onFinished.disconnect(boost::bind(&OutgoingFileTransfer::handleIBBSessionFinished, this, _1));

+ ibbSession.reset();

+ }

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

+ onFinished(error);

+}

+

+void OutgoingFileTransfer::handleIBBSessionFinished(boost::optional<FileTransferError> error) {

+ finish(error);

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/FileTransfer/ReadBytestream.h"

+#include "Swiften/Base/boost_bsignals.h"

+#include "Swiften/FileTransfer/FileTransferError.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamServer.h"

+#include "Swiften/JID/JID.h"

+#include "Swiften/Elements/StreamInitiation.h"

+#include "Swiften/Elements/Bytestreams.h"

+#include "Swiften/Elements/ErrorPayload.h"

+#include "Swiften/FileTransfer/IBBSendSession.h"

+

+namespace Swift {

+ class IQRouter;

+ class SOCKS5BytestreamServer;

+

+ class OutgoingFileTransfer {

+ public:

+ OutgoingFileTransfer(const String& id, const JID& from, const JID& to, const String& name, int size, const String& description, boost::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer);

+

+ void start();

+ void stop();

+

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

+

+ private:

+ void handleStreamInitiationRequestResponse(StreamInitiation::ref, const boost::optional<ErrorPayload>&);

+ void handleBytestreamsRequestResponse(Bytestreams::ref, const boost::optional<ErrorPayload>&);

+ void finish(boost::optional<FileTransferError> error);

+ void handleIBBSessionFinished(boost::optional<FileTransferError> error);

+

+ private:

+ String id;

+ JID from;

+ JID to;

+ String name;

+ int size;

+ String description;

+ boost::shared_ptr<ReadBytestream> bytestream;

+ IQRouter* iqRouter;

+ SOCKS5BytestreamServer* socksServer;

+ boost::shared_ptr<IBBSendSession> ibbSession;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/ReadBytestream.h"

+

+namespace Swift {

+

+ReadBytestream::~ReadBytestream() {

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Base/ByteArray.h"

+

+namespace Swift {

+ class ReadBytestream {

+ public:

+ virtual ~ReadBytestream();

+ virtual ByteArray read(size_t size) = 0;

+ virtual bool isFinished() const = 0;

+ };

+}

+Import("swiften_env")

+

+sources = [

+ "OutgoingFileTransfer.cpp",

+ "ReadBytestream.cpp",

+ "FileReadBytestream.cpp",

+ "SOCKS5BytestreamServer.cpp",

+ "SOCKS5BytestreamServerSession.cpp",

+ "SOCKS5BytestreamRegistry.cpp",

+ "IBBSendSession.cpp",

+ ]

+

+swiften_env.Append(SWIFTEN_OBJECTS = swiften_env.StaticObject(sources))

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/SOCKS5BytestreamRegistry.h"

+

+namespace Swift {

+

+SOCKS5BytestreamRegistry::SOCKS5BytestreamRegistry() {

+}

+

+void SOCKS5BytestreamRegistry::addBytestream(const String& destination, boost::shared_ptr<ReadBytestream> byteStream) {

+ byteStreams[destination] = byteStream;

+}

+

+void SOCKS5BytestreamRegistry::removeBytestream(const String& destination) {

+ byteStreams.erase(destination);

+}

+

+boost::shared_ptr<ReadBytestream> SOCKS5BytestreamRegistry::getBytestream(const String& destination) const {

+ BytestreamMap::const_iterator i = byteStreams.find(destination);

+ if (i != byteStreams.end()) {

+ return i->second;

+ }

+ return boost::shared_ptr<ReadBytestream>();

+}

+

+

+}

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <map>

+

+#include "Swiften/Base/String.h"

+#include "Swiften/FileTransfer/ReadBytestream.h"

+

+namespace Swift {

+ class SOCKS5BytestreamRegistry {

+ public:

+ SOCKS5BytestreamRegistry();

+

+ boost::shared_ptr<ReadBytestream> getBytestream(const String& destination) const;

+ void addBytestream(const String& destination, boost::shared_ptr<ReadBytestream> byteStream);

+ void removeBytestream(const String& destination);

+

+ private:

+ typedef std::map<String, boost::shared_ptr<ReadBytestream> > BytestreamMap;

+ BytestreamMap byteStreams;

+ };

+}

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/SOCKS5BytestreamServer.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/StringCodecs/Hexify.h"

+#include "Swiften/StringCodecs/SHA1.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamServerSession.h"

+

+namespace Swift {

+

+SOCKS5BytestreamServer::SOCKS5BytestreamServer(boost::shared_ptr<ConnectionServer> connectionServer) : connectionServer(connectionServer) {

+}

+

+void SOCKS5BytestreamServer::start() {

+ connectionServer->onNewConnection.connect(boost::bind(&SOCKS5BytestreamServer::handleNewConnection, this, _1));

+}

+

+void SOCKS5BytestreamServer::stop() {

+ connectionServer->onNewConnection.disconnect(boost::bind(&SOCKS5BytestreamServer::handleNewConnection, this, _1));

+}

+

+void SOCKS5BytestreamServer::addBytestream(const String& id, const JID& from, const JID& to, boost::shared_ptr<ReadBytestream> byteStream) {

+ bytestreams.addBytestream(getSOCKSDestinationAddress(id, from, to), byteStream);

+}

+

+void SOCKS5BytestreamServer::removeBytestream(const String& id, const JID& from, const JID& to) {

+ bytestreams.removeBytestream(getSOCKSDestinationAddress(id, from, to));

+}

+

+String SOCKS5BytestreamServer::getSOCKSDestinationAddress(const String& id, const JID& from, const JID& to) {

+ return Hexify::hexify(SHA1::getHash(ByteArray(id + from.toString() + to.toString())));

+}

+

+void SOCKS5BytestreamServer::handleNewConnection(boost::shared_ptr<Connection> connection) {

+ boost::shared_ptr<SOCKS5BytestreamServerSession> session(new SOCKS5BytestreamServerSession(connection, &bytestreams));

+ sessions.push_back(session);

+ session->start();

+}

+

+HostAddressPort SOCKS5BytestreamServer::getAddressPort() const {

+ return connectionServer->getAddressPort();

+}

+

+}

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <map>

+

+#include "Swiften/Network/ConnectionServer.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/JID/JID.h"

+#include "Swiften/FileTransfer/ReadBytestream.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamRegistry.h"

+

+namespace Swift {

+ class SOCKS5BytestreamServerSession;

+

+ class SOCKS5BytestreamServer {

+ public:

+ SOCKS5BytestreamServer(boost::shared_ptr<ConnectionServer> connectionServer);

+

+ HostAddressPort getAddressPort() const;

+

+ void start();

+ void stop();

+

+ void addBytestream(const String& id, const JID& from, const JID& to, boost::shared_ptr<ReadBytestream> byteStream);

+ void removeBytestream(const String& id, const JID& from, const JID& to);

+

+ /*protected:

+ boost::shared_ptr<ReadBytestream> getBytestream(const String& dest);*/

+

+ private:

+ void handleNewConnection(boost::shared_ptr<Connection> connection);

+

+ static String getSOCKSDestinationAddress(const String& id, const JID& from, const JID& to);

+

+ private:

+ friend class SOCKS5BytestreamServerSession;

+

+ boost::shared_ptr<ConnectionServer> connectionServer;

+ SOCKS5BytestreamRegistry bytestreams;

+ std::vector<boost::shared_ptr<SOCKS5BytestreamServerSession> > sessions;

+ };

+}

+

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/FileTransfer/SOCKS5BytestreamServerSession.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Base/ByteArray.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamRegistry.h"

+#include "Swiften/FileTransfer/BytestreamException.h"

+

+namespace Swift {

+

+SOCKS5BytestreamServerSession::SOCKS5BytestreamServerSession(boost::shared_ptr<Connection> connection, SOCKS5BytestreamRegistry* bytestreams) : connection(connection), bytestreams(bytestreams), state(Initial), chunkSize(4096) {

+}

+

+SOCKS5BytestreamServerSession::~SOCKS5BytestreamServerSession() {

+ if (state != Finished && state != Initial) {

+ std::cerr << "Warning: SOCKS5BytestremServerSession unfinished" << std::endl;

+ finish(false);

+ }

+}

+

+void SOCKS5BytestreamServerSession::start() {

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

+ state = WaitingForAuthentication;

+}

+

+void SOCKS5BytestreamServerSession::stop() {

+ finish(false);

+}

+

+void SOCKS5BytestreamServerSession::handleDataRead(const ByteArray& data) {

+ unprocessedData += data;

+ process();

+}

+

+void SOCKS5BytestreamServerSession::process() {

+ if (state == WaitingForAuthentication) {

+ if (unprocessedData.getSize() >= 2) {

+ int authCount = unprocessedData[1];

+ int i = 2;

+ while (i < 2 + authCount && i < unprocessedData.getSize()) {

+ // Skip authentication mechanism

+ ++i;

+ }

+ if (i == 2 + authCount) {

+ // Authentication message is complete

+ if (i != unprocessedData.getSize()) {

+ std::cerr << "SOCKS5BytestreamServerSession: Junk after authentication mechanism";

+ }

+ unprocessedData.clear();

+ connection->write(ByteArray("\x05\x00", 2));

+ state = WaitingForRequest;

+ }

+ }

+ }

+ else if (state == WaitingForRequest) {

+ if (unprocessedData.getSize() >= 5) {

+ ByteArray requestID;

+ int i = 5;

+ int hostnameSize = unprocessedData[4];

+ while (i < 5 + hostnameSize && i < unprocessedData.getSize()) {

+ requestID += unprocessedData[i];

+ ++i;

+ }

+ // Skip the port:

+ i += 2;

+ if (i >= unprocessedData.getSize()) {

+ if (i != unprocessedData.getSize()) {

+ std::cerr << "SOCKS5BytestreamServerSession: Junk after authentication mechanism";

+ }

+ bytestream = bytestreams->getBytestream(requestID.toString());

+ ByteArray result("\x05", 1);

+ result += bytestream ? 0x0 : 0x4;

+ result += ByteArray("\x00\x03", 2);

+ result += static_cast<char>(requestID.getSize());

+ result += requestID + ByteArray("\x00\x00", 2);

+ if (!bytestream) {

+ connection->write(result);

+ finish(true);

+ }

+ else {

+ state = SendingData;

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

+ connection->write(result);

+ }

+ }

+ }

+ }

+}

+

+void SOCKS5BytestreamServerSession::sendData() {

+ if (!bytestream->isFinished()) {

+ try {

+ connection->write(bytestream->read(chunkSize));

+ }

+ catch (const BytestreamException& e) {

+ finish(true);

+ }

+ }

+ else {

+ finish(false);

+ }

+}

+

+void SOCKS5BytestreamServerSession::finish(bool error) {

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

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

+ bytestream.reset();

+ state = Finished;

+ onFinished(error);

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Base/boost_bsignals.h"

+#include "Swiften/Network/Connection.h"

+#include "Swiften/FileTransfer/ReadBytestream.h"

+

+namespace Swift {

+ class SOCKS5BytestreamRegistry;

+

+ class SOCKS5BytestreamServerSession {

+ public:

+ enum State {

+ Initial,

+ WaitingForAuthentication,

+ WaitingForRequest,

+ SendingData,

+ Finished,

+ };

+

+ SOCKS5BytestreamServerSession(boost::shared_ptr<Connection> connection, SOCKS5BytestreamRegistry* registry);

+ ~SOCKS5BytestreamServerSession();

+

+ void setChunkSize(int chunkSize) {

+ this->chunkSize = chunkSize;

+ }

+

+ void start();

+ void stop();

+

+ boost::signal<void (bool /* error */)> onFinished;

+

+ private:

+ void finish(bool error);

+ void process();

+ void handleDataRead(const ByteArray&);

+ void sendData();

+

+ private:

+ boost::shared_ptr<Connection> connection;

+ SOCKS5BytestreamRegistry* bytestreams;

+ ByteArray unprocessedData;

+ State state;

+ int chunkSize;

+ boost::shared_ptr<ReadBytestream> bytestream;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Queries/GenericRequest.h"

+#include "Swiften/Elements/StreamInitiation.h"

+#include "Swiften/Base/Shared.h"

+

+namespace Swift {

+ class StreamInitiationRequest : public GenericRequest<StreamInitiation>, public Shared<StreamInitiationRequest> {

+ public:

+ static ref create(const JID& jid, boost::shared_ptr<StreamInitiation> payload, IQRouter* router) {

+ return ref(new StreamInitiationRequest(jid, payload, router));

+ }

+

+ private:

+ StreamInitiationRequest(const JID& jid, boost::shared_ptr<StreamInitiation> payload, IQRouter* router) : GenericRequest<StreamInitiation>(IQ::Set, jid, payload, router) {

+ }

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <vector>

+#include <boost/bind.hpp>

+

+#include "Swiften/FileTransfer/IBBSendSession.h"

+#include "Swiften/FileTransfer/ByteArrayReadBytestream.h"

+#include "Swiften/Queries/IQRouter.h"

+#include "Swiften/Client/DummyStanzaChannel.h"

+

+using namespace Swift;

+

+class IBBSendSessionTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(IBBSendSessionTest);

+ CPPUNIT_TEST(testStart);

+ CPPUNIT_TEST(testStart_ResponseStartsSending);

+ CPPUNIT_TEST(testResponseContinuesSending);

+ CPPUNIT_TEST(testRespondToAllFinishes);

+ CPPUNIT_TEST(testErrorResponseFinishesWithError);

+ CPPUNIT_TEST(testStopDuringSessionCloses);

+ CPPUNIT_TEST(testStopAfterFinishedDoesNotClose);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ bytestream = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(ByteArray("abcdefg")));

+ }

+

+ void tearDown() {

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ void testStart() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(1234);

+

+ testling->start();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(0, JID("foo@bar.com/baz"), IQ::Set));

+ IBB::ref ibb = stanzaChannel->sentStanzas[0]->getPayload<IBB>();

+ CPPUNIT_ASSERT_EQUAL(IBB::Open, ibb->getAction());

+ CPPUNIT_ASSERT_EQUAL(1234, ibb->getBlockSize());

+ CPPUNIT_ASSERT_EQUAL(String("myid"), ibb->getStreamID());

+ }

+

+ void testStart_ResponseStartsSending() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(3);

+ testling->start();

+

+ stanzaChannel->onIQReceived(createIBBResult());

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(1, JID("foo@bar.com/baz"), IQ::Set));

+ IBB::ref ibb = stanzaChannel->sentStanzas[1]->getPayload<IBB>();

+ CPPUNIT_ASSERT_EQUAL(IBB::Data, ibb->getAction());

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abc"), ibb->getData());

+ CPPUNIT_ASSERT_EQUAL(0, ibb->getSequenceNumber());

+ CPPUNIT_ASSERT_EQUAL(String("myid"), ibb->getStreamID());

+ }

+

+ void testResponseContinuesSending() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(3);

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBResult());

+ stanzaChannel->onIQReceived(createIBBResult());

+

+ CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(2, JID("foo@bar.com/baz"), IQ::Set));

+ IBB::ref ibb = stanzaChannel->sentStanzas[2]->getPayload<IBB>();

+ CPPUNIT_ASSERT_EQUAL(IBB::Data, ibb->getAction());

+ CPPUNIT_ASSERT_EQUAL(ByteArray("def"), ibb->getData());

+ CPPUNIT_ASSERT_EQUAL(1, ibb->getSequenceNumber());

+ CPPUNIT_ASSERT_EQUAL(String("myid"), ibb->getStreamID());

+ }

+

+ void testRespondToAllFinishes() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(3);

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBResult());

+ stanzaChannel->onIQReceived(createIBBResult());

+ stanzaChannel->onIQReceived(createIBBResult());

+ stanzaChannel->onIQReceived(createIBBResult());

+

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(!error);

+ }

+

+ void testErrorResponseFinishesWithError() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(3);

+ testling->start();

+ stanzaChannel->onIQReceived(IQ::createError(JID("baz@fum.com/foo"), stanzaChannel->sentStanzas[0]->getID()));

+

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(error);

+ }

+

+ void testStopDuringSessionCloses() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(3);

+ testling->start();

+ testling->stop();

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<IBB>(1, JID("foo@bar.com/baz"), IQ::Set));

+ IBB::ref ibb = stanzaChannel->sentStanzas[1]->getPayload<IBB>();

+ CPPUNIT_ASSERT_EQUAL(IBB::Close, ibb->getAction());

+ CPPUNIT_ASSERT_EQUAL(String("myid"), ibb->getStreamID());

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(!error);

+ }

+

+ void testStopAfterFinishedDoesNotClose() {

+ std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

+ testling->setBlockSize(16);

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBResult());

+ stanzaChannel->onIQReceived(createIBBResult());

+ CPPUNIT_ASSERT(finished);

+

+ testling->stop();

+

+ CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(stanzaChannel->sentStanzas.size()));

+ }

+

+ private:

+ IQ::ref createIBBResult() {

+ return IQ::createResult(JID("baz@fum.com/dum"), stanzaChannel->sentStanzas[stanzaChannel->sentStanzas.size()-1]->getID(), boost::shared_ptr<IBB>());

+ }

+

+ private:

+ std::auto_ptr<IBBSendSession> createSession(const String& to) {

+ std::auto_ptr<IBBSendSession> session(new IBBSendSession("myid", JID(to), bytestream, iqRouter));

+ session->onFinished.connect(boost::bind(&IBBSendSessionTest::handleFinished, this, _1));

+ return session;

+ }

+

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

+ finished = true;

+ this->error = error;

+ }

+

+ private:

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ bool finished;

+ boost::optional<FileTransferError> error;

+ boost::shared_ptr<ByteArrayReadBytestream> bytestream;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(IBBSendSessionTest);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <boost/bind.hpp>

+

+#include "Swiften/FileTransfer/SOCKS5BytestreamServerSession.h"

+#include "Swiften/FileTransfer/ByteArrayReadBytestream.h"

+#include "Swiften/FileTransfer/SOCKS5BytestreamRegistry.h"

+#include "Swiften/Network/DummyConnection.h"

+#include "Swiften/EventLoop/DummyEventLoop.h"

+#include "Swiften/Base/StartStopper.h"

+

+using namespace Swift;

+

+class SOCKS5BytestreamServerSessionTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(SOCKS5BytestreamServerSessionTest);

+ CPPUNIT_TEST(testAuthenticate);

+ CPPUNIT_TEST(testAuthenticate_Chunked);

+ CPPUNIT_TEST(testRequest);

+ CPPUNIT_TEST(testRequest_UnknownBytestream);

+ CPPUNIT_TEST(testReceiveData);

+ CPPUNIT_TEST(testReceiveData_Chunked);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ receivedDataChunks = 0;

+ eventLoop = new DummyEventLoop();

+ connection = boost::shared_ptr<DummyConnection>(new DummyConnection());

+ connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

+ stream1 = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(ByteArray("abcdefg")));

+ }

+

+ void tearDown() {

+ connection.reset();

+ delete eventLoop;

+ }

+

+ void testAuthenticate() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+

+ receive(ByteArray("\x05\x02\x01\x02"));

+

+ CPPUNIT_ASSERT_EQUAL(ByteArray("\x05\x00", 2), receivedData);

+ }

+

+ void testAuthenticate_Chunked() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+

+ receive(ByteArray("\x05\x02\x01"));

+

+ CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedData.getSize()));

+ receive(ByteArray("\x01"));

+ CPPUNIT_ASSERT_EQUAL(ByteArray("\x05\x00", 2), receivedData);

+ }

+

+ void testRequest() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+ bytestreams.addBytestream("abcdef", stream1);

+ authenticate();

+

+ ByteArray hostname("abcdef");

+ receive(ByteArray("\x05\x01\x00\x03", 4) + hostname.getSize() + hostname + ByteArray("\x00\x00", 2));

+ CPPUNIT_ASSERT_EQUAL(ByteArray("\x05\x00\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13), ByteArray(receivedData.getData(), 13));

+ }

+

+ void testRequest_UnknownBytestream() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+ authenticate();

+

+ ByteArray hostname("abcdef");

+ receive(ByteArray("\x05\x01\x00\x03", 4) + hostname.getSize() + hostname + ByteArray("\x00\x00", 2));

+ CPPUNIT_ASSERT_EQUAL(ByteArray("\x05\x04\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13), receivedData);

+ }

+

+ void testReceiveData() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+ bytestreams.addBytestream("abcdef", stream1);

+ authenticate();

+ request("abcdef");

+ eventLoop->processEvents();

+ skipHeader("abcdef");

+

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdefg"), receivedData);

+ CPPUNIT_ASSERT_EQUAL(2, receivedDataChunks);

+ }

+

+ void testReceiveData_Chunked() {

+ std::auto_ptr<SOCKS5BytestreamServerSession> testling(createSession());

+ testling->setChunkSize(3);

+ StartStopper<SOCKS5BytestreamServerSession> stopper(testling.get());

+ bytestreams.addBytestream("abcdef", stream1);

+ authenticate();

+ request("abcdef");

+ eventLoop->processEvents();

+

+ skipHeader("abcdef");

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdefg"), receivedData);

+ CPPUNIT_ASSERT_EQUAL(4, receivedDataChunks);

+ }

+

+ private:

+ void receive(const ByteArray& data) {

+ connection->receive(data);

+ eventLoop->processEvents();

+ }

+

+ void authenticate() {

+ receive(ByteArray("\x05\x02\x01\x02"));

+ receivedData.clear();

+ receivedDataChunks = 0;

+ }

+

+ void request(const String& hostname) {

+ receive(ByteArray("\x05\x01\x00\x03", 4) + hostname.getUTF8Size() + hostname + ByteArray("\x00\x00", 2));

+ }

+

+ void skipHeader(const String& hostname) {

+ int headerSize = 7 + hostname.getUTF8Size();

+ receivedData = ByteArray(receivedData.getData() + headerSize, receivedData.getSize() - headerSize);

+ }

+

+

+ void handleDataWritten(const ByteArray& data) {

+ receivedData += data;

+ receivedDataChunks++;

+ }

+

+ private:

+ SOCKS5BytestreamServerSession* createSession() {

+ SOCKS5BytestreamServerSession* session = new SOCKS5BytestreamServerSession(connection, &bytestreams);

+ return session;

+ }

+

+ private:

+ DummyEventLoop* eventLoop;

+ SOCKS5BytestreamRegistry bytestreams;

+ boost::shared_ptr<DummyConnection> connection;

+ ByteArray receivedData;

+ int receivedDataChunks;

+ boost::shared_ptr<ByteArrayReadBytestream> stream1;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(SOCKS5BytestreamServerSessionTest);

+ MainEventLoop::postEvent(boost::ref(onDataWritten), shared_from_this());

+HostAddressPort BoostConnection::getLocalAddress() const {

+ return HostAddressPort(socket_.local_endpoint());

+}

+

+

+ HostAddressPort getLocalAddress() const;

+

+HostAddressPort BoostConnectionServer::getAddressPort() const {

+ if (acceptor_) {

+ return HostAddressPort(acceptor_->local_endpoint());

+ }

+ else {

+ return HostAddressPort();

+ }

+}

+

+

+ virtual HostAddressPort getAddressPort() const;

+

+#include "Swiften/Network/HostAddressPort.h"

+ virtual HostAddressPort getLocalAddress() const = 0;

+

+ boost::signal<void ()> onDataWritten;

+#include "Swiften/Network/HostAddressPort.h"

+ virtual HostAddressPort getAddressPort() const = 0;

+

+ class DummyConnection : public Connection, public EventOwner, public boost::enable_shared_from_this<DummyConnection> {

+ public:

+ void listen() {

+ assert(false);

+ }

+ void connect(const HostAddressPort&) {

+ assert(false);

+ }

+ void disconnect() {

+ //assert(false);

+ }

+ void write(const ByteArray& data) {

+ MainEventLoop::postEvent(boost::ref(onDataWritten), shared_from_this());

+ onDataSent(data);

+ }

+ void receive(const ByteArray& data) {

+ MainEventLoop::postEvent(boost::bind(boost::ref(onDataRead), ByteArray(data)), shared_from_this());

+ }

+ HostAddressPort getLocalAddress() const {

+ return localAddress;

+ }

+ boost::signal<void (const ByteArray&)> onDataSent;

+

+ HostAddressPort localAddress;

+ virtual HostAddressPort getLocalAddress() const {

+ return HostAddressPort();

+ }

+

+#include <stdexcept>

+#include <boost/array.hpp>

+ try {

+ address_ = boost::asio::ip::address::from_string(address.getUTF8String());

+ }

+ catch (const std::exception& t) {

+ if (length == 4) {

+ boost::array<unsigned char, 4> data;

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

+ data[i] = address[i];

+ address_ = boost::asio::ip::address(boost::asio::ip::address_v4(data));

+ boost::array<unsigned char, 16> data;

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

+ data[i] = address[i];

+ }

+ address_ = boost::asio::ip::address(boost::asio::ip::address_v6(data));

+HostAddress::HostAddress(const boost::asio::ip::address& address) : address_(address) {

+}

+

+std::string HostAddress::toString() const {

+ return address_.to_string();

+}

+

+bool HostAddress::isValid() const {

+ return !(address_.is_v4() && address_.to_v4().to_ulong() == 0);

+}

+

+#include <boost/asio.hpp>

+ HostAddress(const boost::asio::ip::address& address);

+ bool isValid() const;

+

+ boost::asio::ip::address address_;

+#pragma once

+

+#include <boost/asio.hpp>

+ HostAddressPort(const HostAddress& address = HostAddress(), int port = -1) : address_(address), port_(port) {

+ }

+

+ HostAddressPort(const boost::asio::ip::tcp::endpoint& endpoint) {

+ address_ = HostAddress(endpoint.address());

+ port_ = endpoint.port();

+

+ bool isValid() const {

+ return address_.isValid() && port_ > 0;

+ }

+

+ HostAddressPort getLocalAddress() const { return HostAddressPort(); }

+ CPPUNIT_TEST(testConstructor_Invalid);

+ CPPUNIT_TEST(testConstructor_InvalidString);

+ CPPUNIT_TEST(testToString_Invalid);

+ CPPUNIT_ASSERT(testling.isValid());

+ }

+

+ void testConstructor_Invalid() {

+ HostAddress testling;

+

+ CPPUNIT_ASSERT(!testling.isValid());

+ }

+

+ void testConstructor_InvalidString() {

+ HostAddress testling("invalid");

+

+ CPPUNIT_ASSERT(!testling.isValid());

+ CPPUNIT_ASSERT_EQUAL(std::string("102:304:506:708:90a:b0c:d0e:f11"), testling.toString());

+ }

+

+ void testToString_Invalid() {

+ HostAddress testling;

+

+ CPPUNIT_ASSERT_EQUAL(std::string("0.0.0.0"), testling.toString());

+#pragma once

+ return (tag_.isEmpty() ? true : element == tag_) && (xmlns_.isEmpty() ? true : xmlns_ == ns);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Parser/PayloadParsers/BytestreamsParser.h"

+

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/foreach.h"

+

+namespace Swift {

+

+BytestreamsParser::BytestreamsParser() : level(TopLevel) {

+}

+

+BytestreamsParser::~BytestreamsParser() {

+}

+

+void BytestreamsParser::handleStartElement(const String& element, const String&, const AttributeMap& attributes) {

+ if (level == TopLevel) {

+ getPayloadInternal()->setStreamID(attributes.getAttribute("sid"));

+ }

+ else if (level == PayloadLevel) {

+ if (element == "streamhost") {

+ try {

+ getPayloadInternal()->addStreamHost(Bytestreams::StreamHost(attributes.getAttribute("host"), JID(attributes.getAttribute("jid")), boost::lexical_cast<int>(attributes.getAttribute("port"))));

+ }

+ catch (boost::bad_lexical_cast& e) {

+ }

+ }

+ else if (element == "streamhost-used") {

+ getPayloadInternal()->setUsedStreamHost(JID(attributes.getAttribute("jid")));

+ }

+ }

+ ++level;

+}

+

+void BytestreamsParser::handleEndElement(const String&, const String&) {

+ --level;

+}

+

+void BytestreamsParser::handleCharacterData(const String&) {

+}

+

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

+#include "Swiften/Elements/Bytestreams.h"

+#include "Swiften/Parser/GenericPayloadParser.h"

+

+namespace Swift {

+ class BytestreamsParser : public GenericPayloadParser<Bytestreams> {

+ public:

+ BytestreamsParser();

+ ~BytestreamsParser();

+

+ virtual void handleStartElement(const String& element, const String&, const AttributeMap& attributes);

+ virtual void handleEndElement(const String& element, const String&);

+ virtual void handleCharacterData(const String& data);

+

+ private:

+ enum Level {

+ TopLevel = 0,

+ PayloadLevel = 1,

+ };

+ int level;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Parser/GenericPayloadParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/BytestreamsParser.h"

+

+namespace Swift {

+ class BytestreamsParserFactory : public GenericPayloadParserFactory<BytestreamsParser> {

+ public:

+ BytestreamsParserFactory() : GenericPayloadParserFactory<BytestreamsParser>("query", "http://jabber.org/protocol/bytestreams") {}

+ };

+}

+#include "Swiften/Parser/PayloadParsers/StreamInitiationParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/BytestreamsParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/IBBParserFactory.h"

+ factories_.push_back(shared_ptr<PayloadParserFactory>(new IBBParserFactory()));

+ factories_.push_back(shared_ptr<PayloadParserFactory>(new StreamInitiationParserFactory()));

+ factories_.push_back(shared_ptr<PayloadParserFactory>(new BytestreamsParserFactory()));

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Parser/PayloadParsers/IBBParser.h"

+

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/foreach.h"

+#include "Swiften/StringCodecs/Base64.h"

+

+namespace Swift {

+

+IBBParser::IBBParser() : level(TopLevel) {

+}

+

+IBBParser::~IBBParser() {

+}

+

+void IBBParser::handleStartElement(const String& element, const String&, const AttributeMap& attributes) {

+ if (level == TopLevel) {

+ if (element == "data") {

+ getPayloadInternal()->setAction(IBB::Data);

+ getPayloadInternal()->setStreamID(attributes.getAttribute("sid"));

+ try {

+ getPayloadInternal()->setSequenceNumber(boost::lexical_cast<int>(attributes.getAttribute("seq")));

+ }

+ catch (boost::bad_lexical_cast& e) {

+ }

+ }

+ else if (element == "open") {

+ getPayloadInternal()->setAction(IBB::Open);

+ getPayloadInternal()->setStreamID(attributes.getAttribute("sid"));

+ if (attributes.getAttribute("stanza") == "message") {

+ getPayloadInternal()->setStanzaType(IBB::MessageStanza);

+ }

+ else {

+ getPayloadInternal()->setStanzaType(IBB::IQStanza);

+ }

+ try {

+ getPayloadInternal()->setBlockSize(boost::lexical_cast<int>(attributes.getAttribute("block-size")));

+ }

+ catch (boost::bad_lexical_cast& e) {

+ }

+ }

+ else if (element == "close") {

+ getPayloadInternal()->setAction(IBB::Close);

+ getPayloadInternal()->setStreamID(attributes.getAttribute("sid"));

+ }

+ }

+ ++level;

+}

+

+void IBBParser::handleEndElement(const String& element, const String&) {

+ --level;

+ if (level == TopLevel) {

+ if (element == "data") {

+ std::vector<char> data;

+ for (size_t i = 0; i < currentText.getUTF8Size(); ++i) {

+ char c = currentText[i];

+ if (c >= 48 && c <= 122) {

+ data.push_back(c);

+ }

+ }

+ getPayloadInternal()->setData(Base64::decode(String(&data[0], data.size())));

+ }

+ }

+}

+

+void IBBParser::handleCharacterData(const String& data) {

+ currentText += data;

+}

+

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

+#include "Swiften/Elements/IBB.h"

+#include "Swiften/Parser/GenericPayloadParser.h"

+

+namespace Swift {

+ class IBBParser : public GenericPayloadParser<IBB> {

+ public:

+ IBBParser();

+ ~IBBParser();

+

+ virtual void handleStartElement(const String& element, const String&, const AttributeMap& attributes);

+ virtual void handleEndElement(const String& element, const String&);

+ virtual void handleCharacterData(const String& data);

+

+ private:

+ enum Level {

+ TopLevel = 0,

+ };

+ int level;

+ String currentText;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Parser/GenericPayloadParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/IBBParser.h"

+

+namespace Swift {

+ class IBBParserFactory : public GenericPayloadParserFactory<IBBParser> {

+ public:

+ IBBParserFactory() : GenericPayloadParserFactory<IBBParser>("", "http://jabber.org/protocol/ibb") {}

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Parser/PayloadParsers/StreamInitiationParser.h"

+

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Parser/PayloadParsers/FormParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/FormParser.h"

+#include "Swiften/Base/foreach.h"

+

+

+#define FILE_TRANSFER_NS "http://jabber.org/protocol/si/profile/file-transfer"

+#define FEATURE_NEG_NS "http://jabber.org/protocol/feature-neg"

+

+namespace Swift {

+

+StreamInitiationParser::StreamInitiationParser() : level(TopLevel), formParser(0), inFile(false), inFeature(false) {

+ formParserFactory = new FormParserFactory();

+}

+

+StreamInitiationParser::~StreamInitiationParser() {

+ delete formParserFactory;

+}

+

+void StreamInitiationParser::handleStartElement(const String& element, const String& ns, const AttributeMap& attributes) {

+ if (level == TopLevel) {

+ getPayloadInternal()->setID(attributes.getAttribute("id"));

+ if (!attributes.getAttribute("profile").isEmpty()) {

+ getPayloadInternal()->setIsFileTransfer(attributes.getAttribute("profile") == FILE_TRANSFER_NS);

+ }

+ }

+ else if (level == PayloadLevel) {

+ if (element == "file") {

+ inFile = true;

+ currentFile = StreamInitiation::FileInfo();

+ currentFile.name = attributes.getAttribute("name");

+ try {

+ currentFile.size = boost::lexical_cast<int>(attributes.getAttribute("size"));

+ }

+ catch (boost::bad_lexical_cast& e) {

+ }

+ }

+ else if (element == "feature" && ns == FEATURE_NEG_NS) {

+ inFeature = true;

+ }

+ }

+ else if (level == FileOrFeatureLevel) {

+ if (inFile && element == "desc") {

+ currentText.clear();

+ }

+ else if (inFeature && formParserFactory->canParse(element, ns, attributes)) {

+ formParser = dynamic_cast<FormParser*>(formParserFactory->createPayloadParser());

+ }

+ }

+

+ if (formParser) {

+ formParser->handleStartElement(element, ns, attributes);

+ }

+ ++level;

+}

+

+void StreamInitiationParser::handleEndElement(const String& element, const String& ns) {

+ --level;

+ if (formParser) {

+ formParser->handleEndElement(element, ns);

+ }

+ if (level == TopLevel) {

+ }

+ else if (level == PayloadLevel) {

+ if (element == "file") {

+ getPayloadInternal()->setFileInfo(currentFile);

+ inFile = false;

+ }

+ else if (element == "feature" && ns == FEATURE_NEG_NS) {

+ inFeature = false;

+ }

+ }

+ else if (level == FileOrFeatureLevel) {

+ if (inFile && element == "desc") {

+ currentFile.description = currentText;

+ }

+ else if (formParser) {

+ Form::ref form = formParser->getPayloadInternal();

+ if (form) {

+ FormField::ref field = boost::dynamic_pointer_cast<FormField>(form->getField("stream-method"));

+ if (field) {

+ if (form->getType() == Form::FormType) {

+ foreach (const FormField::Option& option, field->getOptions()) {

+ getPayloadInternal()->addProvidedMethod(option.value);

+ }

+ }

+ else if (form->getType() == Form::SubmitType) {

+ if (field->getRawValues().size() > 0) {

+ getPayloadInternal()->setRequestedMethod(field->getRawValues()[0]);

+ }

+ }

+ }

+ }

+ }

+ }

+}

+

+void StreamInitiationParser::handleCharacterData(const String& data) {

+ if (formParser) {

+ formParser->handleCharacterData(data);

+ }

+ else {

+ currentText += data;

+ }

+}

+

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/optional.hpp>

+

+#include "Swiften/Elements/StreamInitiation.h"

+#include "Swiften/Parser/GenericPayloadParser.h"

+

+namespace Swift {

+ class FormParserFactory;

+ class FormParser;

+

+ class StreamInitiationParser : public GenericPayloadParser<StreamInitiation> {

+ public:

+ StreamInitiationParser();

+ ~StreamInitiationParser();

+

+ virtual void handleStartElement(const String& element, const String&, const AttributeMap& attributes);

+ virtual void handleEndElement(const String& element, const String&);

+ virtual void handleCharacterData(const String& data);

+

+ private:

+ enum Level {

+ TopLevel = 0,

+ PayloadLevel = 1,

+ FileOrFeatureLevel = 2,

+ FormOrDescriptionLevel = 3,

+ };

+ int level;

+ FormParserFactory* formParserFactory;

+ FormParser* formParser;

+ bool inFile;

+ bool inFeature;

+ StreamInitiation::FileInfo currentFile;

+ String currentText;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Parser/GenericPayloadParserFactory.h"

+#include "Swiften/Parser/PayloadParsers/StreamInitiationParser.h"

+

+namespace Swift {

+ class StreamInitiationParserFactory : public GenericPayloadParserFactory<StreamInitiationParser> {

+ public:

+ StreamInitiationParserFactory() : GenericPayloadParserFactory<StreamInitiationParser>("si", "http://jabber.org/protocol/si") {}

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h"

+#include "Swiften/Elements/IBB.h"

+

+using namespace Swift;

+

+class IBBParserTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(IBBParserTest);

+ CPPUNIT_TEST(testParse_Data);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testParse_Data() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse(

+ "<data xmlns='http://jabber.org/protocol/ibb' seq='4'>\n"

+ "\t YWJjZGVmZ2loamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWjEyMzQ1\n"

+ "\t Njc4OTAK\n"

+ "</data>"

+ ));

+

+ IBB::ref ibb = parser.getPayload<IBB>();

+ CPPUNIT_ASSERT(ibb->getAction() == IBB::Data);

+ CPPUNIT_ASSERT_EQUAL(ByteArray("abcdefgihjklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\x0a"), ibb->getData());

+ CPPUNIT_ASSERT_EQUAL(4, ibb->getSequenceNumber());

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(IBBParserTest);

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "Swiften/Parser/PayloadParsers/UnitTest/PayloadsParserTester.h"

+#include "Swiften/Elements/StreamInitiation.h"

+

+using namespace Swift;

+

+class StreamInitiationParserTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(StreamInitiationParserTest);

+ CPPUNIT_TEST(testParse_Request);

+ CPPUNIT_TEST(testParse_Response);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testParse_Request() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse(

+ "<si xmlns='http://jabber.org/protocol/si' id='a0' mime-type='text/plain' profile='http://jabber.org/protocol/si/profile/file-transfer'>"

+ "<file xmlns='http://jabber.org/protocol/si/profile/file-transfer' name='test.txt' size='1022'>"

+ "<desc>This is info about the file.</desc>"

+ "</file>"

+ "<feature xmlns='http://jabber.org/protocol/feature-neg'>"

+ "<x xmlns='jabber:x:data' type='form'>"

+ "<field var='stream-method' type='list-single'>"

+ "<option><value>http://jabber.org/protocol/bytestreams</value></option>"

+ "<option><value>jabber:iq:oob</value></option>"

+ "<option><value>http://jabber.org/protocol/ibb</value></option>"

+ "</field>"

+ "</x>"

+ "</feature>"

+ "</si>"

+ ));

+

+ StreamInitiation::ref si = parser.getPayload<StreamInitiation>();

+ CPPUNIT_ASSERT(si->getIsFileTransfer());

+ CPPUNIT_ASSERT(si->getFileInfo());

+ CPPUNIT_ASSERT_EQUAL(String("test.txt"), si->getFileInfo()->name);

+ CPPUNIT_ASSERT_EQUAL(1022, si->getFileInfo()->size);

+ CPPUNIT_ASSERT_EQUAL(String("This is info about the file."), si->getFileInfo()->description);

+ CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(si->getProvidedMethods().size()));

+ CPPUNIT_ASSERT_EQUAL(String("http://jabber.org/protocol/bytestreams"), si->getProvidedMethods()[0]);

+ CPPUNIT_ASSERT_EQUAL(String("jabber:iq:oob"), si->getProvidedMethods()[1]);

+ CPPUNIT_ASSERT_EQUAL(String("http://jabber.org/protocol/ibb"), si->getProvidedMethods()[2]);

+ }

+

+ void testParse_Response() {

+ PayloadsParserTester parser;

+

+ CPPUNIT_ASSERT(parser.parse(

+ "<si xmlns='http://jabber.org/protocol/si'>"

+ "<feature xmlns='http://jabber.org/protocol/feature-neg'>"

+ "<x xmlns='jabber:x:data' type='submit'>"

+ "<field var='stream-method'>"

+ "<value>http://jabber.org/protocol/bytestreams</value>"

+ "</field>"

+ "</x>"

+ "</feature>"

+ "</si>"

+ ));

+

+ StreamInitiation::ref si = parser.getPayload<StreamInitiation>();

+ CPPUNIT_ASSERT(si->getIsFileTransfer());

+ CPPUNIT_ASSERT_EQUAL(String("http://jabber.org/protocol/bytestreams"), si->getRequestedMethod());

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(StreamInitiationParserTest);

+ "PayloadParsers/IBBParser.cpp",

+ "PayloadParsers/StreamInitiationParser.cpp",

+ "PayloadParsers/BytestreamsParser.cpp",

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "Swiften/FileTransfer/FileReadBytestream.h"

+#include "SwifTools/Application/PlatformApplicationPathProvider.h"

+

+using namespace Swift;

+

+class FileReadBytestreamTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(FileReadBytestreamTest);

+ CPPUNIT_TEST(testRead);

+ CPPUNIT_TEST(testRead_Twice);

+ CPPUNIT_TEST(testIsFinished_NotFinished);

+ CPPUNIT_TEST(testIsFinished_IsFinished);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ pathProvider = new PlatformApplicationPathProvider("FileReadBytestreamTest");

+ }

+

+ void tearDown() {

+ delete pathProvider;

+ }

+

+ void testRead() {

+ std::auto_ptr<FileReadBytestream> testling(createTestling());

+

+ ByteArray result = testling->read(10);

+

+ CPPUNIT_ASSERT_EQUAL(String("/*\n * Copy"), result.toString());

+ }

+

+ void testRead_Twice() {

+ std::auto_ptr<FileReadBytestream> testling(createTestling());

+

+ testling->read(10);

+ ByteArray result = testling->read(10);

+

+ CPPUNIT_ASSERT_EQUAL(String("right (c) "), result.toString());

+ }

+

+ void testIsFinished_NotFinished() {

+ std::auto_ptr<FileReadBytestream> testling(createTestling());

+

+ testling->read(10);

+

+ CPPUNIT_ASSERT(!testling->isFinished());

+ }

+

+ void testIsFinished_IsFinished() {

+ std::auto_ptr<FileReadBytestream> testling(createTestling());

+

+ testling->read(4096);

+

+ CPPUNIT_ASSERT(testling->isFinished());

+ }

+

+ private:

+ FileReadBytestream* createTestling() {

+ return new FileReadBytestream(pathProvider->getExecutableDir() / "FileReadBytestreamTest.cpp");

+ }

+

+ PlatformApplicationPathProvider* pathProvider;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(FileReadBytestreamTest);

+ "FileReadBytestreamTest.cpp",

+ "Serializer/PayloadSerializers/IBBSerializer.cpp",

+ "Serializer/PayloadSerializers/StreamInitiationSerializer.cpp",

+ "Serializer/PayloadSerializers/BytestreamsSerializer.cpp",

+ "FileTransfer",

+ File("FileTransfer/UnitTest/SOCKS5BytestreamServerSessionTest.cpp"),

+ File("FileTransfer/UnitTest/IBBSendSessionTest.cpp"),

+ File("Parser/PayloadParsers/UnitTest/IBBParserTest.cpp"),

+ File("Parser/PayloadParsers/UnitTest/StreamInitiationParserTest.cpp"),

+ File("Serializer/PayloadSerializers/UnitTest/StreamInitiationSerializerTest.cpp"),

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Serializer/PayloadSerializers/BytestreamsSerializer.h"

+

+#include <boost/shared_ptr.hpp>

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/foreach.h"

+#include "Swiften/Serializer/XML/XMLElement.h"

+#include "Swiften/Serializer/PayloadSerializerCollection.h"

+

+

+namespace Swift {

+

+BytestreamsSerializer::BytestreamsSerializer() {

+}

+

+String BytestreamsSerializer::serializePayload(boost::shared_ptr<Bytestreams> bytestreams) const {

+ XMLElement queryElement("query", "http://jabber.org/protocol/bytestreams");

+ queryElement.setAttribute("sid", bytestreams->getStreamID());

+ foreach(const Bytestreams::StreamHost& streamHost, bytestreams->getStreamHosts()) {

+ boost::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost"));

+ streamHostElement->setAttribute("host", streamHost.host);

+ streamHostElement->setAttribute("jid", streamHost.jid.toString());

+ streamHostElement->setAttribute("port", boost::lexical_cast<std::string>(streamHost.port));

+ queryElement.addNode(streamHostElement);

+ }

+

+ if (bytestreams->getUsedStreamHost()) {

+ boost::shared_ptr<XMLElement> streamHostElement(new XMLElement("streamhost-used"));

+ streamHostElement->setAttribute("jid", *bytestreams->getUsedStreamHost());

+ queryElement.addNode(streamHostElement);

+ }

+ return queryElement.serialize();

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Serializer/GenericPayloadSerializer.h"

+#include "Swiften/Elements/Bytestreams.h"

+

+namespace Swift {

+ class PayloadSerializerCollection;

+

+ class BytestreamsSerializer : public GenericPayloadSerializer<Bytestreams> {

+ public:

+ BytestreamsSerializer();

+

+ virtual String serializePayload(boost::shared_ptr<Bytestreams>) const;

+ };

+}

+ if (!option.label.isEmpty()) {

+ optionElement->setAttribute("label", option.label);

+ }

+#include "Swiften/Serializer/PayloadSerializers/IBBSerializer.h"

+#include "Swiften/Serializer/PayloadSerializers/StreamInitiationSerializer.h"

+#include "Swiften/Serializer/PayloadSerializers/ByteStreamsSerializer.h"

+ serializers_.push_back(new IBBSerializer());

+ serializers_.push_back(new StreamInitiationSerializer());

+ serializers_.push_back(new BytestreamsSerializer());

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Serializer/PayloadSerializers/IBBSerializer.h"

+

+#include <boost/shared_ptr.hpp>

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/foreach.h"

+#include "Swiften/Serializer/XML/XMLElement.h"

+#include "Swiften/Serializer/XML/XMLTextNode.h"

+#include "Swiften/Serializer/PayloadSerializerCollection.h"

+#include "Swiften/StringCodecs/Base64.h"

+

+namespace Swift {

+

+IBBSerializer::IBBSerializer() {

+}

+

+String IBBSerializer::serializePayload(boost::shared_ptr<IBB> ibb) const {

+ switch(ibb->getAction()) {

+ case IBB::Data: {

+ XMLElement ibbElement("data", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ if (ibb->getSequenceNumber() >= 0) {

+ ibbElement.setAttribute("seq", boost::lexical_cast<std::string>(ibb->getSequenceNumber()));

+ }

+ ibbElement.addNode(boost::shared_ptr<XMLTextNode>(new XMLTextNode(Base64::encode(ibb->getData()))));

+ return ibbElement.serialize();

+ }

+ case IBB::Open: {

+ XMLElement ibbElement("open", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ switch (ibb->getStanzaType()) {

+ case IBB::IQStanza: ibbElement.setAttribute("stanza", "iq"); break;

+ case IBB::MessageStanza: ibbElement.setAttribute("stanza", "message"); break;

+ }

+ assert(ibb->getBlockSize() > 0);

+ ibbElement.setAttribute("block-size", boost::lexical_cast<std::string>(ibb->getBlockSize()));

+ return ibbElement.serialize();

+ }

+ case IBB::Close: {

+ XMLElement ibbElement("close", "http://jabber.org/protocol/ibb");

+ ibbElement.setAttribute("sid", ibb->getStreamID());

+ return ibbElement.serialize();

+ }

+ }

+ return "";

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Serializer/GenericPayloadSerializer.h"

+#include "Swiften/Elements/IBB.h"

+

+namespace Swift {

+ class PayloadSerializerCollection;

+

+ class IBBSerializer : public GenericPayloadSerializer<IBB> {

+ public:

+ IBBSerializer();

+

+ virtual String serializePayload(boost::shared_ptr<IBB>) const;

+ };

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "Swiften/Serializer/PayloadSerializers/StreamInitiationSerializer.h"

+

+#include <boost/shared_ptr.hpp>

+#include <boost/lexical_cast.hpp>

+

+#include "Swiften/Base/foreach.h"

+#include "Swiften/Serializer/XML/XMLElement.h"

+#include "Swiften/Serializer/XML/XMLTextNode.h"

+#include "Swiften/Serializer/XML/XMLRawTextNode.h"

+#include "Swiften/Serializer/PayloadSerializerCollection.h"

+#include "Swiften/Serializer/PayloadSerializers/FormSerializer.h"

+

+

+#define FILE_TRANSFER_NS "http://jabber.org/protocol/si/profile/file-transfer"

+#define FEATURE_NEG_NS "http://jabber.org/protocol/feature-neg"

+

+namespace Swift {

+

+StreamInitiationSerializer::StreamInitiationSerializer() {

+}

+

+String StreamInitiationSerializer::serializePayload(boost::shared_ptr<StreamInitiation> streamInitiation) const {

+ assert(streamInitiation->getIsFileTransfer());

+

+ XMLElement siElement("si", "http://jabber.org/protocol/si");

+ if (!streamInitiation->getID().isEmpty()) {

+ siElement.setAttribute("id", streamInitiation->getID());

+ }

+ siElement.setAttribute("profile", FILE_TRANSFER_NS);

+

+ if (streamInitiation->getFileInfo()) {

+ StreamInitiation::FileInfo file = *streamInitiation->getFileInfo();

+ boost::shared_ptr<XMLElement> fileElement(new XMLElement("file", "http://jabber.org/protocol/si/profile/file-transfer"));

+ fileElement->setAttribute("name", file.name);

+ if (file.size != -1) {

+ fileElement->setAttribute("size", boost::lexical_cast<std::string>(file.size));

+ }

+ if (!file.description.isEmpty()) {

+ boost::shared_ptr<XMLElement> descElement(new XMLElement("desc"));

+ descElement->addNode(boost::shared_ptr<XMLTextNode>(new XMLTextNode(file.description)));

+ fileElement->addNode(descElement);

+ }

+ siElement.addNode(fileElement);

+ }

+

+ boost::shared_ptr<XMLElement> featureElement(new XMLElement("feature", "http://jabber.org/protocol/feature-neg"));

+ if (streamInitiation->getProvidedMethods().size() > 0) {

+ Form::ref form(new Form(Form::FormType));

+ ListSingleFormField::ref field = ListSingleFormField::create();

+ field->setName("stream-method");

+ foreach(const String& method, streamInitiation->getProvidedMethods()) {

+ field->addOption(FormField::Option("", method));

+ }

+ form->addField(field);

+ featureElement->addNode(boost::shared_ptr<XMLRawTextNode>(new XMLRawTextNode(FormSerializer().serialize(form))));

+ }

+ else if (!streamInitiation->getRequestedMethod().isEmpty()) {

+ Form::ref form(new Form(Form::SubmitType));

+ ListSingleFormField::ref field = ListSingleFormField::create(streamInitiation->getRequestedMethod());

+ field->setName("stream-method");

+ form->addField(field);

+ featureElement->addNode(boost::shared_ptr<XMLRawTextNode>(new XMLRawTextNode(FormSerializer().serialize(form))));

+ }

+ siElement.addNode(featureElement);

+ return siElement.serialize();

+}

+

+}

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include "Swiften/Serializer/GenericPayloadSerializer.h"

+#include "Swiften/Elements/StreamInitiation.h"

+

+namespace Swift {

+ class PayloadSerializerCollection;

+

+ class StreamInitiationSerializer : public GenericPayloadSerializer<StreamInitiation> {

+ public:

+ StreamInitiationSerializer();

+

+ virtual String serializePayload(boost::shared_ptr<StreamInitiation>) const;

+ };

+}

+ field->addOption(FormField::Option("", "none"));

+ "<option><value>none</value></option>"

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "Swiften/Serializer/PayloadSerializers/StreamInitiationSerializer.h"

+

+using namespace Swift;

+

+class StreamInitiationSerializerTest : public CppUnit::TestFixture{

+ CPPUNIT_TEST_SUITE(StreamInitiationSerializerTest);

+ CPPUNIT_TEST(testSerialize_Request);

+ CPPUNIT_TEST(testSerialize_Response);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testSerialize_Request() {

+ StreamInitiationSerializer testling;

+ boost::shared_ptr<StreamInitiation> streamInitiation(new StreamInitiation());

+ StreamInitiation::FileInfo fileInfo("test.txt", "This is info about the file.", 1022);

+ streamInitiation->setID("a0");

+ streamInitiation->setFileInfo(fileInfo);

+ streamInitiation->addProvidedMethod("http://jabber.org/protocol/bytestreams");

+ streamInitiation->addProvidedMethod("jabber:iq:oob");

+ streamInitiation->addProvidedMethod("http://jabber.org/protocol/ibb");

+

+ CPPUNIT_ASSERT_EQUAL(String(

+ "<si id=\"a0\" profile=\"http://jabber.org/protocol/si/profile/file-transfer\" xmlns=\"http://jabber.org/protocol/si\">"

+ "<file name=\"test.txt\" size=\"1022\" xmlns=\"http://jabber.org/protocol/si/profile/file-transfer\">"

+ "<desc>This is info about the file.</desc>"

+ "</file>"

+ "<feature xmlns=\"http://jabber.org/protocol/feature-neg\">"

+ "<x type=\"form\" xmlns=\"jabber:x:data\">"

+ "<field type=\"list-single\" var=\"stream-method\">"

+ "<option><value>http://jabber.org/protocol/bytestreams</value></option>"

+ "<option><value>jabber:iq:oob</value></option>"

+ "<option><value>http://jabber.org/protocol/ibb</value></option>"

+ "</field>"

+ "</x>"

+ "</feature>"

+ "</si>"

+ ), testling.serialize(streamInitiation));

+ }

+

+ void testSerialize_Response() {

+ StreamInitiationSerializer testling;

+ boost::shared_ptr<StreamInitiation> streamInitiation(new StreamInitiation());

+ streamInitiation->setRequestedMethod("http://jabber.org/protocol/bytestreams");

+

+ CPPUNIT_ASSERT_EQUAL(String(

+ "<si profile=\"http://jabber.org/protocol/si/profile/file-transfer\" xmlns=\"http://jabber.org/protocol/si\">"

+ "<feature xmlns=\"http://jabber.org/protocol/feature-neg\">"

+ "<x type=\"submit\" xmlns=\"jabber:x:data\">"

+ "<field type=\"list-single\" var=\"stream-method\">"

+ "<value>http://jabber.org/protocol/bytestreams</value>"

+ "</field>"

+ "</x>"

+ "</feature>"

+ "</si>"

+ ), testling.serialize(streamInitiation));

+ }

+

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(StreamInitiationSerializerTest);