+ return operator<<(os, s.getDataVector());

+}

+

+std::ostream& operator<<(std::ostream& os, const std::vector<unsigned char>& s) {

+std::vector<unsigned char> ByteArray::create(const std::string& s) {

+ return std::vector<unsigned char>(s.begin(), s.end());

+}

+

+std::vector<unsigned char> ByteArray::create(const char* c) {

+ std::vector<unsigned char> data;

+ while (*c) {

+ data.push_back(static_cast<unsigned char>(*c));

+ ++c;

+ }

+ return data;

+}

+

+std::vector<unsigned char> ByteArray::create(const char* c, size_t n) {

+ std::vector<unsigned char> data;

+ if (n > 0) {

+ data.resize(n);

+ memcpy(&data[0], c, n);

+ }

+ return data;

+}

+

+std::vector<unsigned char> ByteArray::create(const unsigned char* c, size_t n) {

+ std::vector<unsigned char> data;

+ if (n > 0) {

+ data.resize(n);

+ memcpy(&data[0], c, n);

+ }

+ return data;

+}

+

+ const std::vector<unsigned char>& getDataVector() const {

+ return data_;

+ }

+

+ static std::vector<unsigned char> create(const std::string& s);

+ static std::vector<unsigned char> create(const char* c);

+ static std::vector<unsigned char> create(const unsigned char* c, size_t n);

+ static std::vector<unsigned char> create(const char* c, size_t n);

+

+std::ostream& operator<<(std::ostream& os, const std::vector<unsigned char>& s);

+ bool isResultAtIndex(size_t index, const std::string& id) {

+ if (index >= sentStanzas.size()) {

+ return false;

+ }

+ boost::shared_ptr<IQ> iqStanza = boost::dynamic_pointer_cast<IQ>(sentStanzas[index]);

+ return iqStanza && iqStanza->getType() == IQ::Result && iqStanza->getID() == id;

+ }

+

+ bool isErrorAtIndex(size_t index, const std::string& id) {

+ if (index >= sentStanzas.size()) {

+ return false;

+ }

+ boost::shared_ptr<IQ> iqStanza = boost::dynamic_pointer_cast<IQ>(sentStanzas[index]);

+ return iqStanza && iqStanza->getType() == IQ::Error && iqStanza->getID() == id;

+ }

+

+#include <vector>

+#include <boost/shared_ptr.hpp>

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

+ static IBB::ref createIBBData(const std::string& streamID, int sequenceNumber, const std::vector<unsigned char>& data) {

+ const std::vector<unsigned char>& getData() const {

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

+ std::vector<unsigned char> data;

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

+ class JingleContentPayload : public Payload {

+ typedef boost::shared_ptr<JingleContentPayload> ref;

+ Creator getCreator() const {

+ return creator;

+ }

+

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

+ return name;

+ }

+

+#include <boost/shared_ptr.hpp>

+

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

+ class JingleIBBTransportPayload : public JingleTransportPayload {

+ typedef boost::shared_ptr<JingleIBBTransportPayload> ref;

+

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

+ void addContent(JingleContentPayload::ref content) {

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

+ std::vector<JingleContentPayload::ref> contents;

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

+// FIXME: Remove Bytestreams, and replace by our own candidate

+

+ class JingleS5BTransportPayload : public JingleTransportPayload {

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

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

+ OutgoingSIFileTransfer* transfer;

+#include <vector>

+

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

+ ByteArrayReadBytestream(const std::vector<unsigned char>& data) : data(data), position(0) {

+ virtual std::vector<unsigned char> read(size_t size) {

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

+ readSize = data.size() - position;

+ std::vector<unsigned char> result(data.begin() + position, data.begin() + position + readSize);

+ return position >= data.size();

+ std::vector<unsigned char> 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 <Swiften/FileTransfer/WriteBytestream.h>

+

+namespace Swift {

+ class ByteArrayWriteBytestream : public WriteBytestream {

+ public:

+ ByteArrayWriteBytestream() {

+ }

+

+ virtual void write(const std::vector<unsigned char>& bytes) {

+ data.insert(data.end(), bytes.begin(), bytes.end());

+ }

+

+ const std::vector<unsigned char>& getData() const {

+ return data;

+ }

+

+ private:

+ std::vector<unsigned char> data;

+ };

+}

+std::vector<unsigned char> FileReadBytestream::read(size_t size) {

+ std::vector<unsigned char> result;

+ stream->read(reinterpret_cast<char*>(&result[0]), size);

+ virtual std::vector<unsigned char> read(size_t size);

+void FileWriteBytestream::write(const std::vector<unsigned char>& data) {

+ stream->write(reinterpret_cast<const char*>(&data[0]), data.size());

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

+ virtual void write(const std::vector<unsigned char>&);

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

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

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

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

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

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

+class IBBReceiveSession::IBBResponder : public SetResponder<IBB> {

+ public:

+ IBBResponder(IBBReceiveSession* session, IQRouter* router) : SetResponder<IBB>(router), session(session), sequenceNumber(0), receivedSize(0) {

+ }

+

+ virtual bool handleSetRequest(const JID& from, const JID&, const std::string& id, IBB::ref ibb) {

+ if (from == session->from && ibb->getStreamID() == session->id) {

+ if (ibb->getAction() == IBB::Data) {

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

+ session->onDataReceived(ibb->getData());

+ receivedSize += ibb->getData().size();

+ sequenceNumber++;

+ sendResponse(from, id, IBB::ref());

+ if (receivedSize >= session->size) {

+ if (receivedSize > session->size) {

+ std::cerr << "Warning: Received more data than expected" << std::endl;

+ }

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

+ }

+ }

+ else {

+ SWIFT_LOG(warning) << "Received data out of order" << std::endl;

+ sendError(from, id, ErrorPayload::NotAcceptable, ErrorPayload::Cancel);

+ session->finish(FileTransferError(FileTransferError::ClosedError));

+ }

+ }

+ else if (ibb->getAction() == IBB::Open) {

+ sendResponse(from, id, IBB::ref());

+ }

+ else if (ibb->getAction() == IBB::Close) {

+ sendResponse(from, id, IBB::ref());

+ session->finish(FileTransferError(FileTransferError::ClosedError));

+ }

+ return true;

+ }

+ return false;

+ }

+

+ private:

+ IBBReceiveSession* session;

+ int sequenceNumber;

+ size_t receivedSize;

+};

+

+

+IBBReceiveSession::IBBReceiveSession(

+ const std::string& id,

+ const JID& from,

+ size_t size,

+ IQRouter* router) :

+ id(id),

+ from(from),

+ size(size),

+ router(router),

+ active(false) {

+ responder = new IBBResponder(this, router);

+ if (active) {

+ SWIFT_LOG(warning) << "Session still active" << std::endl;

+ }

+ delete responder;

+ responder->start();

+ responder->stop();

+ if (active) {

+ if (router->isAvailable()) {

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

+ }

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

+#include <boost/optional/optional_fwd.hpp>

+ class IBBReceiveSession {

+ IBBReceiveSession(

+ const std::string& id,

+ const JID& from,

+ size_t size,

+ IQRouter* router);

+ boost::signal<void (const std::vector<unsigned char>&)> onDataReceived;

+ class IBBResponder;

+ friend class IBBResponder;

+

+ IBBResponder* responder;

+ std::vector<unsigned char> data = bytestream->read(blockSize);

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

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

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

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

+bool IncomingFileTransferManager::handleIncomingJingleSession(JingleSession::ref session, const std::vector<JingleContentPayload::ref>& contents) {

+ if (JingleContentPayload::ref content = Jingle::getContentWithDescription<JingleFileTransferDescription>(contents)) {

+ if (content->getTransport<JingleIBBTransportPayload>() || content->getTransport<JingleS5BTransportPayload>()) {

+ RemoteJingleTransportCandidateSelectorFactory* a;

+ LocalJingleTransportCandidateGeneratorFactory* b;

+ IncomingJingleFileTransfer::ref transfer = boost::make_shared<IncomingJingleFileTransfer>(session, content, a, b, router);

+ class RemoteJingleTransportCandidateSelectorFactory;

+ class LocalJingleTransportCandidateGeneratorFactory;

+ bool handleIncomingJingleSession(JingleSession::ref session, const std::vector<JingleContentPayload::ref>& contents);

+#include <boost/bind.hpp>

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

+

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

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

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

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

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

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

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

+

+IncomingJingleFileTransfer::IncomingJingleFileTransfer(

+ JingleSession::ref session,

+ JingleContentPayload::ref content,

+ RemoteJingleTransportCandidateSelectorFactory* candidateSelectorFactory,

+ LocalJingleTransportCandidateGeneratorFactory* candidateGeneratorFactory,

+ IQRouter* router) :

+ session(session),

+ router(router),

+ initialContent(content),

+ contentID(content->getName(), content->getCreator()),

+ state(Initial),

+ remoteTransportCandidateSelectFinished(false),

+ localTransportCandidateSelectFinished(false) {

+

+ candidateSelector = candidateSelectorFactory->createCandidateSelector();

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

+

+ candidateGenerator = candidateGeneratorFactory->createCandidateGenerator();

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

+

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

+ session->onTransportReplaceReceived.connect(boost::bind(&IncomingJingleFileTransfer::handleTransportReplaceReceived, this, _1, _2));

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

+

+ description = initialContent->getDescription<JingleFileTransferDescription>();

+ assert(description);

+}

+

+IncomingJingleFileTransfer::~IncomingJingleFileTransfer() {

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

+ session->onTransportReplaceReceived.disconnect(boost::bind(&IncomingJingleFileTransfer::handleTransportReplaceReceived, this, _1, _2));

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

+

+ candidateGenerator->onLocalTransportCandidatesGenerated.disconnect(boost::bind(&IncomingJingleFileTransfer::handleLocalTransportCandidatesGenerated, this, _1));

+ delete candidateGenerator;

+ candidateSelector->onRemoteTransportCandidateSelectFinished.disconnect(boost::bind(&IncomingJingleFileTransfer::handleRemoteTransportCandidateSelectFinished, this, _1));

+ delete candidateSelector;

+ assert(!stream);

+

+ if (JingleIBBTransportPayload::ref ibbTransport = initialContent->getTransport<JingleIBBTransportPayload>()) {

+ setActiveTransport(createIBBTransport(ibbTransport));

+ session->accept();

+ }

+ else if (JingleS5BTransportPayload::ref s5bTransport = initialContent->getTransport<JingleS5BTransportPayload>()) {

+ state = CreatingInitialTransports;

+ candidateSelector->addRemoteTransportCandidates(s5bTransport);

+ candidateGenerator->generateLocalTransportCandidates();

+ }

+ else {

+ assert(false);

+ }

+}

+

+

+void IncomingJingleFileTransfer::handleLocalTransportCandidatesGenerated(JingleTransportPayload::ref candidates) {

+ if (state == CreatingInitialTransports) {

+ if (!candidates) {

+ localTransportCandidateSelectFinished = true;

+ }

+ session->accept(candidates);

+ state = NegotiatingTransport;

+ candidateSelector->selectCandidate();

+ }

+}

+

+

+void IncomingJingleFileTransfer::handleRemoteTransportCandidateSelectFinished(JingleTransportPayload::ref transport) {

+ remoteTransportCandidateSelectFinished = true;

+ selectedRemoteTransportCandidate = transport;

+ session->sendTransportInfo(contentID, transport);

+ checkCandidateSelected();

+}

+

+void IncomingJingleFileTransfer::checkCandidateSelected() {

+ if (localTransportCandidateSelectFinished && remoteTransportCandidateSelectFinished) {

+ if (candidateGenerator->isActualCandidate(selectedLocalTransportCandidate) && candidateSelector->isActualCandidate(selectedRemoteTransportCandidate)) {

+ if (candidateGenerator->getPriority(selectedLocalTransportCandidate) > candidateSelector->getPriority(selectedRemoteTransportCandidate)) {

+ setActiveTransport(candidateGenerator->selectTransport(selectedLocalTransportCandidate));

+ }

+ else {

+ setActiveTransport(candidateSelector->selectTransport(selectedRemoteTransportCandidate));

+ }

+ }

+ else if (candidateSelector->isActualCandidate(selectedRemoteTransportCandidate)) {

+ setActiveTransport(candidateSelector->selectTransport(selectedRemoteTransportCandidate));

+ }

+ else if (candidateGenerator->isActualCandidate(selectedLocalTransportCandidate)) {

+ setActiveTransport(candidateGenerator->selectTransport(selectedLocalTransportCandidate));

+ }

+ else {

+ state = WaitingForFallbackOrTerminate;

+ }

+ }

+}

+

+void IncomingJingleFileTransfer::setActiveTransport(JingleTransport::ref transport) {

+ state = Transferring;

+ activeTransport = transport;

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

+ activeTransport->start();

+}

+

+void IncomingJingleFileTransfer::handleSessionTerminateReceived() {

+ // TODO

+ state = Terminated;

+}

+

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

+ stream->write(data);

+}

+

+

+void IncomingJingleFileTransfer::handleTransportInfoReceived(const JingleContentID&, JingleTransportPayload::ref transport) {

+ localTransportCandidateSelectFinished = true;

+ selectedLocalTransportCandidate = transport;

+ if (candidateGenerator->isActualCandidate(transport)) {

+ candidateSelector->setMinimumPriority(candidateGenerator->getPriority(transport));

+ }

+ checkCandidateSelected();

+}

+

+void IncomingJingleFileTransfer::handleTransportReplaceReceived(const JingleContentID& content, JingleTransportPayload::ref transport) {

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

+ setActiveTransport(createIBBTransport(ibbTransport));

+ session->acceptTransport(content, transport);

+ }

+ else {

+ session->rejectTransport(content, transport);

+ }

+}

+

+void IncomingJingleFileTransfer::stopActiveTransport() {

+ if (activeTransport) {

+ activeTransport->stop();

+ activeTransport->onDataReceived.disconnect(boost::bind(&IncomingJingleFileTransfer::handleTransportDataReceived, this, _1));

+ }

+}

+

+JingleIncomingIBBTransport::ref IncomingJingleFileTransfer::createIBBTransport(JingleIBBTransportPayload::ref ibbTransport) {

+ return boost::make_shared<JingleIncomingIBBTransport>(session->getInitiator(), ibbTransport->getSessionID(), description->getOffer()->size, router);

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

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

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

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

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

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

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

+ class IQRouter;

+ class RemoteJingleTransportCandidateSelectorFactory;

+ class LocalJingleTransportCandidateGeneratorFactory;

+ class RemoteJingleTransportCandidateSelector;

+ class LocalJingleTransportCandidateGenerator;

+

+ enum State {

+ Initial,

+ CreatingInitialTransports,

+ NegotiatingTransport,

+ Transferring,

+ WaitingForFallbackOrTerminate,

+ Terminated

+ };

+ IncomingJingleFileTransfer(

+ JingleSession::ref,

+ JingleContentPayload::ref content,

+ RemoteJingleTransportCandidateSelectorFactory*,

+ LocalJingleTransportCandidateGeneratorFactory*,

+ IQRouter* router);

+ ~IncomingJingleFileTransfer();

+ void handleSessionTerminateReceived();

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

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

+ void handleLocalTransportCandidatesGenerated(JingleTransportPayload::ref candidates);

+ void handleRemoteTransportCandidateSelectFinished(JingleTransportPayload::ref candidate);

+ void setActiveTransport(JingleTransport::ref transport);

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

+ void stopActiveTransport();

+ void checkCandidateSelected();

+ JingleIncomingIBBTransport::ref createIBBTransport(JingleIBBTransportPayload::ref ibbTransport);

+

+ private:

+ JingleSession::ref session;

+ IQRouter* router;

+ JingleContentPayload::ref initialContent;

+ JingleContentID contentID;

+ State state;

+ JingleFileTransferDescription::ref description;

+ RemoteJingleTransportCandidateSelector* candidateSelector;

+ LocalJingleTransportCandidateGenerator* candidateGenerator;

+ bool remoteTransportCandidateSelectFinished;

+ JingleTransportPayload::ref selectedRemoteTransportCandidate;

+ bool localTransportCandidateSelectFinished;

+ JingleTransportPayload::ref selectedLocalTransportCandidate;

+

+ JingleTransport::ref activeTransport;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

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

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

+}

+

+void JingleIncomingIBBTransport::start() {

+ ibbSession.start();

+}

+

+void JingleIncomingIBBTransport::stop() {

+ ibbSession.stop();

+}

+

+}

+/*

+ * Copyright (c) 2011 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/JingleTransport.h>

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

+

+namespace Swift {

+ class JingleIncomingIBBTransport : public JingleTransport {

+ public:

+ typedef boost::shared_ptr<JingleIncomingIBBTransport> ref;

+

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

+

+ virtual void start();

+ virtual void stop();

+

+ private:

+ IBBReceiveSession ibbSession;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+JingleTransport::~JingleTransport() {

+

+}

+

+}

+/*

+ * Copyright (c) 2011 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>

+

+namespace Swift {

+ class JingleTransport {

+ public:

+ typedef boost::shared_ptr<JingleTransport> ref;

+

+ virtual ~JingleTransport();

+

+ virtual void start() = 0;

+ virtual void stop() = 0;

+

+ boost::signal<void (const std::vector<unsigned char>&)> onDataReceived;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+LocalJingleTransportCandidateGenerator::~LocalJingleTransportCandidateGenerator() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

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

+

+namespace Swift {

+ class LocalJingleTransportCandidateGenerator {

+ public:

+ virtual ~LocalJingleTransportCandidateGenerator();

+

+ virtual void generateLocalTransportCandidates() = 0;

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref) = 0;

+ virtual int getPriority(JingleTransportPayload::ref) = 0;

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

+

+ boost::signal<void (JingleTransportPayload::ref)> onLocalTransportCandidatesGenerated;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+LocalJingleTransportCandidateGeneratorFactory::~LocalJingleTransportCandidateGeneratorFactory() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class LocalJingleTransportCandidateGenerator;

+

+ class LocalJingleTransportCandidateGeneratorFactory {

+ public:

+ virtual ~LocalJingleTransportCandidateGeneratorFactory();

+

+ virtual LocalJingleTransportCandidateGenerator* createCandidateGenerator() = 0;

+ };

+}

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

+OutgoingFileTransfer::~OutgoingFileTransfer() {

+ virtual ~OutgoingFileTransfer();

+ virtual void start() = 0;

+ virtual void stop() = 0;

+/*

+ * 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/OutgoingSIFileTransfer.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 {

+

+OutgoingSIFileTransfer::OutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::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 OutgoingSIFileTransfer::start() {

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

+ streamInitiation->setID(id);

+ streamInitiation->setFileInfo(StreamInitiationFileInfo(name, description, size));

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

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

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

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

+ request->send();

+}

+

+void OutgoingSIFileTransfer::stop() {

+}

+

+void OutgoingSIFileTransfer::handleStreamInitiationRequestResponse(StreamInitiation::ref response, ErrorPayload::ref 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(&OutgoingSIFileTransfer::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(&OutgoingSIFileTransfer::handleIBBSessionFinished, this, _1));

+ ibbSession->start();

+ }

+ }

+}

+

+void OutgoingSIFileTransfer::handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref error) {

+ if (error) {

+ finish(FileTransferError());

+ }

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

+}

+

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

+ if (ibbSession) {

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

+ ibbSession.reset();

+ }

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

+ onFinished(error);

+}

+

+void OutgoingSIFileTransfer::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/OutgoingFileTransfer.h>

+#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 OutgoingSIFileTransfer : public OutgoingFileTransfer {

+ public:

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

+

+ virtual void start();

+ virtual void stop();

+

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

+

+ private:

+ void handleStreamInitiationRequestResponse(StreamInitiation::ref, ErrorPayload::ref);

+ void handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref);

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

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

+

+ private:

+ std::string id;

+ JID from;

+ JID to;

+ std::string name;

+ int size;

+ std::string description;

+ boost::shared_ptr<ReadBytestream> bytestream;

+ IQRouter* iqRouter;

+ SOCKS5BytestreamServer* socksServer;

+ boost::shared_ptr<IBBSendSession> ibbSession;

+ };

+}

+#include <vector>

+ virtual std::vector<unsigned char> read(size_t size) = 0;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+RemoteJingleTransportCandidateSelector::~RemoteJingleTransportCandidateSelector() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

+

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

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

+

+namespace Swift {

+ class RemoteJingleTransportCandidateSelector {

+ public:

+ virtual ~RemoteJingleTransportCandidateSelector();

+

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

+ virtual void selectCandidate() = 0;

+ virtual void setMinimumPriority(int) = 0;

+

+ virtual bool isActualCandidate(JingleTransportPayload::ref) = 0;

+ virtual int getPriority(JingleTransportPayload::ref) = 0;

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

+

+ boost::signal<void (JingleTransportPayload::ref)> onRemoteTransportCandidateSelectFinished;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+RemoteJingleTransportCandidateSelectorFactory::~RemoteJingleTransportCandidateSelectorFactory() {

+}

+

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class RemoteJingleTransportCandidateSelector;

+

+ class RemoteJingleTransportCandidateSelectorFactory {

+ public:

+ virtual ~RemoteJingleTransportCandidateSelectorFactory();

+

+ virtual RemoteJingleTransportCandidateSelector* createCandidateSelector() = 0;

+ };

+}

+Import("swiften_env", "env")

+ "OutgoingSIFileTransfer.cpp",

+ "IncomingFileTransferManager.cpp",

+ "RemoteJingleTransportCandidateSelector.cpp",

+ "RemoteJingleTransportCandidateSelectorFactory.cpp",

+ "LocalJingleTransportCandidateGenerator.cpp",

+ "LocalJingleTransportCandidateGeneratorFactory.cpp",

+ "JingleTransport.cpp",

+ "JingleIncomingIBBTransport.cpp",

+

+env.Append(UNITTEST_SOURCES = [

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

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

+ File("UnitTest/IBBReceiveSessionTest.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 <vector>

+#include <boost/bind.hpp>

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

+

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

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

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

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

+

+using namespace Swift;

+

+class IBBReceiveSessionTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(IBBReceiveSessionTest);

+ CPPUNIT_TEST(testOpen);

+ CPPUNIT_TEST(testReceiveData);

+ CPPUNIT_TEST(testReceiveMultipleData);

+ CPPUNIT_TEST(testReceiveDataForOtherSession);

+ CPPUNIT_TEST(testReceiveDataOutOfOrder);

+ CPPUNIT_TEST(testReceiveLastData);

+ CPPUNIT_TEST(testReceiveClose);

+ CPPUNIT_TEST(testStopWhileActive);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ stanzaChannel = new DummyStanzaChannel();

+ iqRouter = new IQRouter(stanzaChannel);

+ }

+

+ void tearDown() {

+ delete iqRouter;

+ delete stanzaChannel;

+ }

+

+ void testOpen() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(0, "id-open"));

+ CPPUNIT_ASSERT(!finished);

+

+ testling->stop();

+ }

+

+ void testReceiveData() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(1, "id-a"));

+ CPPUNIT_ASSERT(ByteArray::create("abc") == receivedData);

+ CPPUNIT_ASSERT(!finished);

+

+ testling->stop();

+ }

+

+ void testReceiveMultipleData() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(2, "id-b"));

+ CPPUNIT_ASSERT(ByteArray::create("abcdef") == receivedData);

+ CPPUNIT_ASSERT(!finished);

+

+ testling->stop();

+ }

+

+ void testReceiveDataForOtherSession() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("othersession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isErrorAtIndex(1, "id-a"));

+

+ testling->stop();

+ }

+

+ void testReceiveDataOutOfOrder() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isErrorAtIndex(2, "id-b"));

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(error);

+

+ testling->stop();

+ }

+

+ void testReceiveLastData() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession", 6));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 0, ByteArray::create("abc")), "foo@bar.com/baz", "id-a"));

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBData("mysession", 1, ByteArray::create("def")), "foo@bar.com/baz", "id-b"));

+

+ CPPUNIT_ASSERT(stanzaChannel->isResultAtIndex(2, "id-b"));

+ CPPUNIT_ASSERT(ByteArray::create("abcdef") == receivedData);

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(!error);

+

+ testling->stop();

+ }

+

+ void testReceiveClose() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBClose("mysession"), "foo@bar.com/baz", "id-close"));

+

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(error);

+

+ testling->stop();

+ }

+

+ void testStopWhileActive() {

+ std::auto_ptr<IBBReceiveSession> testling(createSession("foo@bar.com/baz", "mysession"));

+ testling->start();

+ stanzaChannel->onIQReceived(createIBBRequest(IBB::createIBBOpen("mysession", 0x10), "foo@bar.com/baz", "id-open"));

+

+ testling->stop();

+

+ 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(std::string("mysession"), ibb->getStreamID());

+ CPPUNIT_ASSERT(finished);

+ CPPUNIT_ASSERT(!error);

+ }

+

+ private:

+ IQ::ref createIBBRequest(IBB::ref ibb, const JID& from, const std::string& id) {

+ IQ::ref request = IQ::createRequest(IQ::Set, JID("baz@fum.com/dum"), id, ibb);

+ request->setFrom(from);

+ return request;

+ }

+

+ IBBReceiveSession* createSession(const std::string& from, const std::string& id, size_t size = 0x1000) {

+ IBBReceiveSession* session = new IBBReceiveSession(id, JID(from), size, iqRouter);

+ session->onDataReceived.connect(boost::bind(&IBBReceiveSessionTest::handleDataReceived, this, _1));

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

+ return session;

+ }

+

+

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

+ finished = true;

+ this->error = error;

+ }

+

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

+ receivedData.insert(receivedData.end(), data.begin(), data.end());

+ }

+

+ private:

+ DummyStanzaChannel* stanzaChannel;

+ IQRouter* iqRouter;

+ bool finished;

+ boost::optional<FileTransferError> error;

+ std::vector<unsigned char> receivedData;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(IBBReceiveSessionTest);

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

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

+ CPPUNIT_ASSERT(ByteArray::create("abc") == ibb->getData());

+ CPPUNIT_ASSERT(ByteArray::create("def") == ibb->getData());

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

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

+ CPPUNIT_ASSERT(ByteArray::create("\x05\x00", 2) == receivedData);

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

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

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

+ CPPUNIT_ASSERT(ByteArray::create("\x05\x00", 2) == receivedData);

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

+ CPPUNIT_ASSERT(ByteArray::create("\x05\x00\x00\x03\x06\x61\x62\x63\x64\x65\x66\x00\x00", 13) == ByteArray::create(&receivedData[0], 13));

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

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

+ CPPUNIT_ASSERT(ByteArray::create("abcdefg") == receivedData);

+ CPPUNIT_ASSERT(ByteArray::create("abcdefg") == receivedData);

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

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

+ receivedData = ByteArray::create(&receivedData[headerSize], receivedData.size() - headerSize);

+ receivedData.insert(receivedData.end(), data.begin(), data.end());

+ std::vector<unsigned char> receivedData;

+#include <vector>

+ virtual void write(const std::vector<unsigned char>&) = 0;

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

+ virtual bool handleIncomingJingleSession(JingleSession::ref, const std::vector<JingleContentPayload::ref>& contents) = 0;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <vector>

+

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

+

+namespace Swift {

+ namespace Jingle {

+ template<typename T>

+ JingleContentPayload::ref getContentWithDescription(const std::vector<JingleContentPayload::ref>& contents) {

+ for (size_t i = 0; i < contents.size(); ++i) {

+ if (contents[i]->getDescription<T>()) {

+ return contents[i];

+ }

+ }

+ return JingleContentPayload::ref();

+ }

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+

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

+

+namespace Swift {

+ class JingleContentID {

+ public:

+ JingleContentID(const std::string& name, JingleContentPayload::Creator creator) : name(name), creator(creator) {

+ }

+

+ private:

+ std::string name;

+ JingleContentPayload::Creator creator;

+ };

+}

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

+ JingleSessionImpl::ref session = boost::make_shared<JingleSessionImpl>(payload->getInitiator(), payload->getSessionID());

+ sessionManager->handleIncomingSession(from, session, payload->getContents());

+ JingleSessionImpl::ref session = sessionManager->getSession(from, payload->getSessionID());

+JingleSession::JingleSession(const JID& initiator, const std::string& id) : initiator(initiator), id(id) {

+#include <string>

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

+ class JingleContentID;

+

+ JingleSession(const JID& initiator, const std::string& id);

+ const JID& getInitiator() const {

+ return initiator;

+ std::string getID() const {

+ return id;

+ virtual void terminate(JinglePayload::Reason::Type reason) = 0;

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

+ virtual void sendTransportInfo(const JingleContentID&, JingleTransportPayload::ref) = 0;

+ virtual void acceptTransport(const JingleContentID&, JingleTransportPayload::ref) = 0;

+ virtual void rejectTransport(const JingleContentID&, JingleTransportPayload::ref) = 0;

+ public:

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

+ boost::signal<void (const JingleContentID&, JingleTransportPayload::ref)> onTransportInfoReceived;

+ boost::signal<void (const JingleContentID&, JingleTransportPayload::ref)> onTransportReplaceReceived;

+ JID initiator;

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

+

+namespace Swift {

+

+JingleSessionImpl::JingleSessionImpl(const JID& initiator, const std::string& id) : JingleSession(initiator, id) {

+}

+

+void JingleSessionImpl::handleIncomingAction(JinglePayload::ref) {

+}

+

+void JingleSessionImpl::terminate(JinglePayload::Reason::Type reason) {

+ JinglePayload::ref payload = boost::make_shared<JinglePayload>(JinglePayload::SessionTerminate, getID());

+ payload->setReason(JinglePayload::Reason(reason));

+ //onAction(payload)

+}

+

+void JingleSessionImpl::acceptTransport(const JingleContentID&, JingleTransportPayload::ref) {

+

+}

+

+void JingleSessionImpl::rejectTransport(const JingleContentID&, JingleTransportPayload::ref) {

+

+}

+

+void JingleSessionImpl::accept(JingleTransportPayload::ref) {

+}

+

+void JingleSessionImpl::sendTransportInfo(const JingleContentID&, JingleTransportPayload::ref) {

+

+}

+

+

+

+}

+/*

+ * Copyright (c) 2011 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/Jingle/JingleSession.h>

+

+namespace Swift {

+ class JingleSessionImpl : public JingleSession {

+ friend class JingleResponder;

+ public:

+ typedef boost::shared_ptr<JingleSessionImpl> ref;

+

+ JingleSessionImpl(const JID& initiator, const std::string& id);

+

+ virtual void terminate(JinglePayload::Reason::Type reason);

+ virtual void accept(JingleTransportPayload::ref);

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

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

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

+

+ private:

+ void handleIncomingAction(JinglePayload::ref);

+ };

+}

+JingleSessionImpl::ref JingleSessionManager::getSession(const JID& jid, const std::string& id) const {

+ return i != incomingSessions.end() ? i->second : JingleSessionImpl::ref();

+void JingleSessionManager::handleIncomingSession(const JID& from, JingleSessionImpl::ref session, const std::vector<JingleContentPayload::ref>& contents) {

+ if (handler->handleIncomingJingleSession(session, contents)) {

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

+ JingleSessionImpl::ref getSession(const JID& jid, const std::string& id) const;

+ void handleIncomingSession(const JID& from, JingleSessionImpl::ref, const std::vector<JingleContentPayload::ref>& contents);

+ typedef std::map<JIDSession, JingleSessionImpl::ref> SessionMap;

+ "JingleSession.cpp",

+ "JingleSessionImpl.cpp",

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

+ CPPUNIT_ASSERT(ByteArray::create("abcdefgihjklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890\x0a") == ibb->getData());

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

+ std::vector<unsigned char> result = testling->read(10);

+ CPPUNIT_ASSERT(ByteArray::create("/*\n * Copy") == result);

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

+