+ size_t readSize = size;

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

+ readSize = data.size() - position;

+ }

+ boost::shared_ptr<ByteArray> result = boost::make_shared<ByteArray>(

+ data.begin() + boost::numeric_cast<long long>(position),

+ data.begin() + boost::numeric_cast<long long>(position) + boost::numeric_cast<long long>(readSize));

+ onRead(*result);

+ position += readSize;

+ return result;

+ append(data, moreData);

+ onDataAvailable();

+ class SWIFTEN_API ByteArrayReadBytestream : public ReadBytestream {

+ public:

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

+ }

+ virtual boost::shared_ptr<ByteArray> read(size_t size);

+ virtual bool isFinished() const {

+ return position >= data.size() && dataComplete;

+ }

+ virtual void setDataComplete(bool b) {

+ dataComplete = b;

+ }

+ void addData(const std::vector<unsigned char>& moreData);

+ private:

+ std::vector<unsigned char> data;

+ size_t position;

+ bool dataComplete;

+ };

+ class SWIFTEN_API ByteArrayWriteBytestream : public WriteBytestream {

+ public:

+ ByteArrayWriteBytestream() {

+ }

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

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

+ onWrite(bytes);

+ return true;

+ }

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

+ return data;

+ }

+ private:

+ std::vector<unsigned char> data;

+ };

+ class SWIFTEN_API BytestreamException : public std::exception {

+ public:

+ BytestreamException() {

+ }

+ };

+ class SWIFTEN_API BytestreamsRequest : public GenericRequest<Bytestreams> {

+ public:

+ typedef boost::shared_ptr<BytestreamsRequest> ref;

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

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

+ }

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

+ return ref(new BytestreamsRequest(from, to, payload, router));

+ }

+ private:

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

+ }

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

+ }

+ };

+ const JID& initiator,

+ const JID& responder,

+ Role role,

+ SOCKS5BytestreamRegistry* s5bRegistry,

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxy,

+ IDGenerator* idGenerator,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto,

+ IQRouter* router,

+ const FileTransferOptions& options) :

+ initiator(initiator),

+ responder(responder),

+ role(role),

+ s5bRegistry(s5bRegistry),

+ s5bServerManager(s5bServerManager),

+ s5bProxy(s5bProxy),

+ crypto(crypto),

+ router(router) {

+

+ localCandidateGenerator = new LocalJingleTransportCandidateGenerator(

+ s5bServerManager,

+ s5bProxy,

+ role == Initiator ? initiator : responder,

+ idGenerator,

+ options);

+ localCandidateGenerator->onLocalTransportCandidatesGenerated.connect(

+ boost::bind(&DefaultFileTransferTransporter::handleLocalCandidatesGenerated, this, _1));

+

+ remoteCandidateSelector = new RemoteJingleTransportCandidateSelector(

+ connectionFactory,

+ timerFactory,

+ options);

+ remoteCandidateSelector->onCandidateSelectFinished.connect(

+ boost::bind(&DefaultFileTransferTransporter::handleRemoteCandidateSelectFinished, this, _1, _2));

+ DefaultFileTransferTransporter::stopGeneratingLocalCandidates();

+ remoteCandidateSelector->onCandidateSelectFinished.disconnect(

+ boost::bind(&DefaultFileTransferTransporter::handleRemoteCandidateSelectFinished, this, _1, _2));

+ delete remoteCandidateSelector;

+

+ localCandidateGenerator->onLocalTransportCandidatesGenerated.disconnect(

+ boost::bind(&DefaultFileTransferTransporter::handleLocalCandidatesGenerated, this, _1));

+ delete localCandidateGenerator;

+ s5bSessionID = s5bRegistry->generateSessionID();

+ this->s5bSessionID = s5bSessionID;

+ localCandidateGenerator->start();

+ localCandidateGenerator->stop();

+

+ const std::vector<JingleS5BTransportPayload::Candidate>& candidates) {

+ s5bRegistry->setHasBytestream(getSOCKS5DstAddr(), true);

+ s5bProxy->connectToProxies(getSOCKS5DstAddr());

+ onLocalCandidatesGenerated(s5bSessionID, candidates, getSOCKS5DstAddr());

+ const boost::optional<JingleS5BTransportPayload::Candidate>& candidate,

+ boost::shared_ptr<SOCKS5BytestreamClientSession> session) {

+ remoteS5BClientSession = session;

+ onRemoteCandidateSelectFinished(s5bSessionID, candidate);

+ const std::vector<JingleS5BTransportPayload::Candidate>& candidates, const std::string& dstAddr) {

+ remoteCandidateSelector->setSOCKS5DstAddr(dstAddr.empty() ? getRemoteCandidateSOCKS5DstAddr() : dstAddr);

+ remoteCandidateSelector->addCandidates(candidates);

+ remoteCandidateSelector->startSelectingCandidate();

+ remoteCandidateSelector->stopSelectingCandidate();

+ onProxyActivated(sessionID, error);

+ // activate proxy

+ SWIFT_LOG(debug) << "Start activating proxy " << proxyServiceJID.toString() << " with sid = " << s5bSessionID << "." << std::endl;

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

+ proxyRequest->setSID(s5bSessionID);

+ proxyRequest->setActivate(role == Initiator ? responder : initiator);

+

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

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

+ request->send();

+ // TODO

+ assert(false);

+ const std::string& sessionID, unsigned int blockSize, boost::shared_ptr<ReadBytestream> stream) {

+ if (s5bServerManager->getServer()) {

+ closeLocalSession();

+ }

+ closeRemoteSession();

+ boost::shared_ptr<IBBSendSession> ibbSession = boost::make_shared<IBBSendSession>(

+ sessionID, initiator, responder, stream, router);

+ ibbSession->setBlockSize(blockSize);

+ return boost::make_shared<IBBSendTransportSession>(ibbSession);

+ const std::string& sessionID, unsigned long long size, boost::shared_ptr<WriteBytestream> stream) {

+ if (s5bServerManager->getServer()) {

+ closeLocalSession();

+ }

+ closeRemoteSession();

+ boost::shared_ptr<IBBReceiveSession> ibbSession = boost::make_shared<IBBReceiveSession>(

+ sessionID, initiator, responder, size, stream, router);

+ return boost::make_shared<IBBReceiveTransportSession>(ibbSession);

+ boost::shared_ptr<ReadBytestream> stream, const JingleS5BTransportPayload::Candidate& /* candidate */) {

+ closeLocalSession();

+ return boost::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(

+ remoteS5BClientSession, stream);

+ boost::shared_ptr<WriteBytestream> stream, const JingleS5BTransportPayload::Candidate& /* candidate */) {

+ closeLocalSession();

+ return boost::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(

+ remoteS5BClientSession, stream);

+ s5bRegistry->setHasBytestream(getSOCKS5DstAddr(), false);

+ std::vector<boost::shared_ptr<SOCKS5BytestreamServerSession> > serverSessions =

+ s5bServerManager->getServer()->getSessions(getSOCKS5DstAddr());

+ while (serverSessions.size() > 1) {

+ boost::shared_ptr<SOCKS5BytestreamServerSession> session = serverSessions.back();

+ serverSessions.pop_back();

+ session->stop();

+ }

+ return !serverSessions.empty() ? serverSessions.front() : boost::shared_ptr<SOCKS5BytestreamServerSession>();

+ boost::shared_ptr<ReadBytestream> stream, const JingleS5BTransportPayload::Candidate& candidate) {

+ closeRemoteSession();

+ boost::shared_ptr<TransportSession> transportSession;

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

+ SOCKS5BytestreamClientSession::ref proxySession = s5bProxy->getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());

+ assert(proxySession);

+ transportSession = boost::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);

+ }

+

+ if (!transportSession) {

+ boost::shared_ptr<SOCKS5BytestreamServerSession> serverSession = getServerSession();

+ if (serverSession) {

+ transportSession = boost::make_shared<S5BTransportSession<SOCKS5BytestreamServerSession> >(serverSession, stream);

+ }

+ }

+

+ if (!transportSession) {

+ transportSession = boost::make_shared<FailingTransportSession>();

+ }

+ return transportSession;

+ boost::shared_ptr<WriteBytestream> stream, const JingleS5BTransportPayload::Candidate& candidate) {

+ closeRemoteSession();

+ boost::shared_ptr<TransportSession> transportSession;

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

+ SOCKS5BytestreamClientSession::ref proxySession = s5bProxy->getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());

+ assert(proxySession);

+ transportSession = boost::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);

+ }

+

+ if (!transportSession) {

+ boost::shared_ptr<SOCKS5BytestreamServerSession> serverSession = getServerSession();

+ if (serverSession) {

+ transportSession = boost::make_shared<S5BTransportSession<SOCKS5BytestreamServerSession> >(serverSession, stream);

+ }

+ }

+

+ if (!transportSession) {

+ transportSession = boost::make_shared<FailingTransportSession>();

+ }

+ return transportSession;

+ std::string result;

+ if (role == Initiator) {

+ result = getInitiatorCandidateSOCKS5DstAddr();

+ SWIFT_LOG(debug) << "Initiator S5B DST.ADDR = " << s5bSessionID << " + " << initiator.toString() << " + " << responder.toString() << " : " << result << std::endl;

+ }

+ else {

+ result = getResponderCandidateSOCKS5DstAddr();

+ SWIFT_LOG(debug) << "Responder S5B DST.ADDR = " << s5bSessionID << " + " << responder.toString() << " + " << initiator.toString() << " : " << result << std::endl;

+ }

+ return result;

+ return Hexify::hexify(crypto->getSHA1Hash(createSafeByteArray(s5bSessionID + initiator.toString() + responder.toString())));

+ return Hexify::hexify(crypto->getSHA1Hash(createSafeByteArray(s5bSessionID + responder.toString() + initiator.toString())));

+ if (role == Initiator) {

+ return getResponderCandidateSOCKS5DstAddr();

+ }

+ else {

+ return getInitiatorCandidateSOCKS5DstAddr();

+ }

+ if (role == Responder) {

+ return getResponderCandidateSOCKS5DstAddr();

+ }

+ else {

+ return getInitiatorCandidateSOCKS5DstAddr();

+ }

+ s5bRegistry->setHasBytestream(getSOCKS5DstAddr(), false);

+ if (s5bServerManager->getServer()) {

+ std::vector<boost::shared_ptr<SOCKS5BytestreamServerSession> > serverSessions = s5bServerManager->getServer()->getSessions(getSOCKS5DstAddr());

+ foreach(boost::shared_ptr<SOCKS5BytestreamServerSession> session, serverSessions) {

+ session->stop();

+ }

+ }

+ if (remoteS5BClientSession) {

+ remoteS5BClientSession->stop();

+ remoteS5BClientSession.reset();

+ }

+ class LocalJingleTransportCandidateGenerator;

+ class RemoteJingleTransportCandidateSelector;

+ class SOCKS5BytestreamRegistry;

+ class SOCKS5BytestreamServerManager;

+ class SOCKS5BytestreamProxiesManager;

+ class SOCKS5BytestreamClientSession;

+ class SOCKS5BytestreamServerSession;

+ class IDGenerator;

+ class IQRouter;

+ class ReadBytestream;

+ class WriteBytestream;

+ class ConnectionFactory;

+ class TimerFactory;

+ class CryptoProvider;

+ class FileTransferOptions;

+ class SWIFTEN_API DefaultFileTransferTransporter : public FileTransferTransporter {

+ public:

+ enum Role {

+ Initiator,

+ Responder

+ };

+ DefaultFileTransferTransporter(

+ const JID& initiator,

+ const JID& responder,

+ Role role,

+ SOCKS5BytestreamRegistry*,

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxy,

+ IDGenerator* idGenerator,

+ ConnectionFactory*,

+ TimerFactory*,

+ CryptoProvider*,

+ IQRouter*,

+ const FileTransferOptions&);

+ virtual ~DefaultFileTransferTransporter();

+ virtual void initialize();

+ virtual void initialize(const std::string& s5bSessionID);

+ virtual void startGeneratingLocalCandidates() SWIFTEN_OVERRIDE;

+ virtual void stopGeneratingLocalCandidates() SWIFTEN_OVERRIDE;

+ virtual void addRemoteCandidates(

+ const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string&) SWIFTEN_OVERRIDE;

+ virtual void startTryingRemoteCandidates() SWIFTEN_OVERRIDE;

+ virtual void stopTryingRemoteCandidates() SWIFTEN_OVERRIDE;

+ virtual void startActivatingProxy(const JID& jid) SWIFTEN_OVERRIDE;

+ virtual void stopActivatingProxy() SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createIBBSendSession(

+ const std::string& sessionID, unsigned int blockSize, boost::shared_ptr<ReadBytestream>) SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createIBBReceiveSession(

+ const std::string& sessionID, unsigned long long size, boost::shared_ptr<WriteBytestream>) SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession(

+ boost::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession(

+ boost::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession(

+ boost::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession(

+ boost::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) SWIFTEN_OVERRIDE;

+ private:

+ void handleLocalCandidatesGenerated(const std::vector<JingleS5BTransportPayload::Candidate>&);

+ void handleRemoteCandidateSelectFinished(

+ const boost::optional<JingleS5BTransportPayload::Candidate>&,

+ boost::shared_ptr<SOCKS5BytestreamClientSession>);

+ void handleActivateProxySessionResult(const std::string& sessionID, ErrorPayload::ref error);

+ void closeLocalSession();

+ void closeRemoteSession();

+ boost::shared_ptr<SOCKS5BytestreamServerSession> getServerSession();

+ std::string getSOCKS5DstAddr() const;

+ std::string getInitiatorCandidateSOCKS5DstAddr() const;

+ std::string getResponderCandidateSOCKS5DstAddr() const;

+ std::string getRemoteCandidateSOCKS5DstAddr() const;

+ std::string getLocalCandidateSOCKS5DstAddr() const;

+

+ private:

+ JID initiator;

+ JID responder;

+ Role role;

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamServerManager* s5bServerManager;

+ SOCKS5BytestreamProxiesManager* s5bProxy;

+ CryptoProvider* crypto;

+ IQRouter* router;

+ LocalJingleTransportCandidateGenerator* localCandidateGenerator;

+ RemoteJingleTransportCandidateSelector* remoteCandidateSelector;

+ std::string s5bSessionID;

+ boost::shared_ptr<SOCKS5BytestreamClientSession> remoteS5BClientSession;

+ };

+ SOCKS5BytestreamRegistry* s5bRegistry,

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxiesManager,

+ IDGenerator* idGenerator,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* cryptoProvider,

+ IQRouter* iqRouter) :

+ s5bRegistry(s5bRegistry),

+ s5bServerManager(s5bServerManager),

+ s5bProxiesManager(s5bProxiesManager),

+ idGenerator(idGenerator),

+ connectionFactory(connectionFactory),

+ timerFactory(timerFactory),

+ cryptoProvider(cryptoProvider),

+ iqRouter(iqRouter)

+ const JID& initiator, const JID& responder, const FileTransferOptions& options) {

+ DefaultFileTransferTransporter* transporter = new DefaultFileTransferTransporter(

+ initiator,

+ responder,

+ DefaultFileTransferTransporter::Initiator,

+ s5bRegistry,

+ s5bServerManager,

+ s5bProxiesManager,

+ idGenerator,

+ connectionFactory,

+ timerFactory,

+ cryptoProvider,

+ iqRouter,

+ options);

+ transporter->initialize();

+ return transporter;

+ const JID& initiator, const JID& responder, const std::string& s5bSessionID, const FileTransferOptions& options) {

+ DefaultFileTransferTransporter* transporter = new DefaultFileTransferTransporter(

+ initiator,

+ responder,

+ DefaultFileTransferTransporter::Responder,

+ s5bRegistry,

+ s5bServerManager,

+ s5bProxiesManager,

+ idGenerator,

+ connectionFactory,

+ timerFactory,

+ cryptoProvider,

+ iqRouter,

+ options);

+ transporter->initialize(s5bSessionID);

+ return transporter;

+ class SOCKS5BytestreamRegistry;

+ class SOCKS5BytestreamServerManager;

+ class SOCKS5BytestreamProxiesManager;

+ class IDGenerator;

+ class ConnectionFactory;

+ class TimerFactory;

+ class CryptoProvider;

+ class IQRouter;

+ class SWIFTEN_API DefaultFileTransferTransporterFactory : public FileTransferTransporterFactory {

+ public:

+ DefaultFileTransferTransporterFactory(

+ SOCKS5BytestreamRegistry*,

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxy,

+ IDGenerator* idGenerator,

+ ConnectionFactory*,

+ TimerFactory*,

+ CryptoProvider*,

+ IQRouter*);

+ virtual ~DefaultFileTransferTransporterFactory();

+ virtual FileTransferTransporter* createInitiatorTransporter(

+ const JID& initiator, const JID& responder, const FileTransferOptions&) SWIFTEN_OVERRIDE;

+ virtual FileTransferTransporter* createResponderTransporter(

+ const JID& initiator, const JID& responder, const std::string& s5bSessionID, const FileTransferOptions&) SWIFTEN_OVERRIDE;

+ private:

+ SOCKS5BytestreamRegistry* s5bRegistry;

+ SOCKS5BytestreamServerManager* s5bServerManager;

+ SOCKS5BytestreamProxiesManager* s5bProxiesManager;

+ IDGenerator* idGenerator;

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+ CryptoProvider* cryptoProvider;

+ IQRouter* iqRouter;

+ };

+ public:

+ virtual ~FailingTransportSession() {

+ }

+ virtual void start() SWIFTEN_OVERRIDE {

+ assert(false);

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

+ }

+ virtual void stop() SWIFTEN_OVERRIDE {

+ }

+ if (stream) {

+ stream->close();

+ delete stream;

+ stream = NULL;

+ }

+ if (!stream) {

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

+ }

+ boost::shared_ptr<ByteArray> result = boost::make_shared<ByteArray>();

+ result->resize(size);

+ assert(stream->good());

+ stream->read(reinterpret_cast<char*>(vecptr(*result)), boost::numeric_cast<std::streamsize>(size));

+ result->resize(boost::numeric_cast<size_t>(stream->gcount()));

+ onRead(*result);

+ return result;

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

+ class SWIFTEN_API FileReadBytestream : public ReadBytestream {

+ public:

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

+ virtual ~FileReadBytestream();

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

+ virtual bool isFinished() const;

+ private:

+ boost::filesystem::path file;

+ boost::filesystem::ifstream* stream;

+ };

+ state_ = state;

+ onStateChanged(state);

+ filename_ = name;

+ fileSizeInBytes_ = size;

+ description_ = description;

+ /**

+ * The FileTransfer class provides a general interface for file-transfer

+ * implmenetations. Currently, only Jingle File Transfer based on XEP-0234 is

+ * implementated in the \ref OutgoingJingleFileTransfer and

+ * \ref IncomingJingleFileTransfer classes.

+ */

+ class SWIFTEN_API FileTransfer {

+ public:

+ struct State {

+ enum Type {

+ Initial,

+ WaitingForStart,

+ Negotiating,

+ WaitingForAccept,

+ Transferring,

+ Canceled,

+ Failed,

+ Finished

+ };

+

+ State(Type type, const std::string& message = "") : type(type), message(message) {}

+

+ Type type;

+ std::string message;

+ };

+ typedef boost::shared_ptr<FileTransfer> ref;

+

+ public:

+ FileTransfer();

+ virtual ~FileTransfer();

+

+ virtual void cancel() = 0;

+

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

+ return filename_;

+ }

+

+ boost::uintmax_t getFileSizeInBytes() const {

+ return fileSizeInBytes_;

+ }

+

+ const State& getState() const {

+ return state_;

+ }

+

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

+ return description_;

+ }

+

+ public:

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

+ boost::signal<void (const State&)> onStateChanged;

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

+

+ protected:

+ void setState(const State& state);

+ void setFileInfo(const std::string& name, boost::uintmax_t size, const std::string& description);

+

+ private:

+ boost::uintmax_t fileSizeInBytes_;

+ std::string filename_;

+ std::string description_;

+ State state_;

+ };

+ class SWIFTEN_API FileTransferError {

+ public:

+ enum Type {

+ UnknownError,

+ PeerError,

+ ReadError,

+ WriteError,

+ ClosedError

+ };

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

+ Type getType() const {

+ return type;

+ }

+ private:

+ Type type;

+ };

+ if (info) {

+ return info->hasFeature(DiscoInfo::JingleFeature)

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

+ && (info->hasFeature(DiscoInfo::JingleTransportsIBBFeature) || info->hasFeature(DiscoInfo::JingleTransportsS5BFeature));

+ }

+ return false;

+ class ReadBytestream;

+

+ class SWIFTEN_API FileTransferManager {

+ public:

+ virtual ~FileTransferManager();

+

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(

+ const JID& to,

+ const boost::filesystem::path& filepath,

+ const std::string& description,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions& = FileTransferOptions()) = 0;

+ virtual OutgoingFileTransfer::ref createOutgoingFileTransfer(

+ const JID& to,

+ const std::string& filename,

+ const std::string& description,

+ const boost::uintmax_t sizeInBytes,

+ const boost::posix_time::ptime& lastModified,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions& = FileTransferOptions()) = 0;

+

+ static bool isSupportedBy(const DiscoInfo::ref info);

+

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

+ };

+ const JID& ownJID,

+ JingleSessionManager* jingleSessionManager,

+ IQRouter* router,

+ EntityCapsProvider* capsProvider,

+ PresenceOracle* presOracle,

+ ConnectionFactory* connectionFactory,

+ ConnectionServerFactory* connectionServerFactory,

+ TimerFactory* timerFactory,

+ DomainNameResolver* domainNameResolver,

+ NetworkEnvironment* networkEnvironment,

+ NATTraverser* natTraverser,

+ CryptoProvider* crypto) :

+ iqRouter(router),

+ capsProvider(capsProvider),

+ presenceOracle(presOracle) {

+ bytestreamRegistry = new SOCKS5BytestreamRegistry();

+ s5bServerManager = new SOCKS5BytestreamServerManager(

+ bytestreamRegistry, connectionServerFactory, networkEnvironment, natTraverser);

+ bytestreamProxy = new SOCKS5BytestreamProxiesManager(connectionFactory, timerFactory, domainNameResolver, iqRouter, JID(ownJID.getDomain()));

+

+ transporterFactory = new DefaultFileTransferTransporterFactory(

+ bytestreamRegistry,

+ s5bServerManager,

+ bytestreamProxy,

+ &idGenerator,

+ connectionFactory,

+ timerFactory,

+ crypto,

+ iqRouter);

+ outgoingFTManager = new OutgoingFileTransferManager(

+ jingleSessionManager,

+ iqRouter,

+ transporterFactory,

+ timerFactory,

+ crypto);

+ incomingFTManager = new IncomingFileTransferManager(

+ jingleSessionManager,

+ transporterFactory,

+ timerFactory,

+ crypto);

+ incomingFTManager->onIncomingFileTransfer.connect(onIncomingFileTransfer);

+ delete incomingFTManager;

+ delete outgoingFTManager;

+ delete transporterFactory;

+ delete bytestreamProxy;

+ delete s5bServerManager;

+ delete bytestreamRegistry;

+ s5bServerManager->stop();

+ JID fullReceipientJID;

+ int priority = INT_MIN;

+

+ //getAllPresence(bareJID) gives you all presences for the bare JID (i.e. all resources) Isode Limited. @ 11:11

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

+

+ //iterate over them

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

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

+ // look up caps from the jid

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

+ if (isSupportedBy(info)) {

+ priority = pres->getPriority();

+ fullReceipientJID = pres->getFrom();

+ }

+ }

+ }

+

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

+ const JID& to,

+ const boost::filesystem::path& filepath,

+ const std::string& description,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions& config) {

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

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

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

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

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

+ const JID& to,

+ const std::string& filename,

+ const std::string& description,

+ const boost::uintmax_t sizeInBytes,

+ const boost::posix_time::ptime& lastModified,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions& config) {

+ JingleFileTransferFileInfo fileInfo;

+ fileInfo.setDate(lastModified);

+ fileInfo.setSize(sizeInBytes);

+ fileInfo.setName(filename);

+ fileInfo.setDescription(description);

+

+ JID receipient = to;

+

+ if(receipient.isBare()) {

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

+ if (fullJID.is_initialized()) {

+ receipient = fullJID.get();

+ } else {

+ return OutgoingFileTransfer::ref();

+ }

+ }

+

+ assert(!iqRouter->getJID().isBare());

+

+ DiscoInfo::ref capabilities = capsProvider->getCaps(receipient);

+

+ FileTransferOptions options = config;

+ if (capabilities) {

+ if (!capabilities->hasFeature(DiscoInfo::JingleTransportsS5BFeature)) {

+ options = options.withAssistedAllowed(false).withDirectAllowed(false).withProxiedAllowed(false);

+ }

+ if (!capabilities->hasFeature(DiscoInfo::JingleTransportsIBBFeature)) {

+ options = options.withInBandAllowed(false);

+ }

+ }

+ else {

+ SWIFT_LOG(warning) << "No entity capabilities information for " << receipient.toString() << std::endl;

+ }

+

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

+ class ConnectionFactory;

+ class ConnectionServerFactory;

+ class CryptoProvider;

+ class DomainNameResolver;

+ class EntityCapsProvider;

+ class FileTransferTransporterFactory;

+ class IQRouter;

+ class IncomingFileTransferManager;

+ class JID;

+ class JingleSessionManager;

+ class NATTraverser;

+ class NetworkEnvironment;

+ class OutgoingFileTransferManager;

+ class PresenceOracle;

+ class ReadBytestream;

+ class SOCKS5BytestreamProxiesManager;

+ class SOCKS5BytestreamRegistry;

+ class SOCKS5BytestreamServerManager;

+ class TimerFactory;

+ class SWIFTEN_API FileTransferManagerImpl : public FileTransferManager {

+ public:

+ FileTransferManagerImpl(

+ const JID& ownFullJID,

+ JingleSessionManager* jingleSessionManager,

+ IQRouter* router,

+ EntityCapsProvider* capsProvider,

+ PresenceOracle* presOracle,

+ ConnectionFactory* connectionFactory,

+ ConnectionServerFactory* connectionServerFactory,

+ TimerFactory* timerFactory,

+ DomainNameResolver* domainNameResolver,

+ NetworkEnvironment* networkEnvironment,

+ NATTraverser* natTraverser,

+ CryptoProvider* crypto);

+ virtual ~FileTransferManagerImpl();

+ OutgoingFileTransfer::ref createOutgoingFileTransfer(

+ const JID& to,

+ const boost::filesystem::path& filepath,

+ const std::string& description,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions&) SWIFTEN_OVERRIDE;

+ OutgoingFileTransfer::ref createOutgoingFileTransfer(

+ const JID& to,

+ const std::string& filename,

+ const std::string& description,

+ const boost::uintmax_t sizeInBytes,

+ const boost::posix_time::ptime& lastModified,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ const FileTransferOptions&) SWIFTEN_OVERRIDE;

+

+ void start();

+ void stop();

+

+ private:

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

+

+ private:

+ OutgoingFileTransferManager* outgoingFTManager;

+ IncomingFileTransferManager* incomingFTManager;

+ FileTransferTransporterFactory* transporterFactory;

+ IQRouter* iqRouter;

+ EntityCapsProvider* capsProvider;

+ PresenceOracle* presenceOracle;

+ IDGenerator idGenerator;

+ SOCKS5BytestreamRegistry* bytestreamRegistry;

+ SOCKS5BytestreamProxiesManager* bytestreamProxy;

+ SOCKS5BytestreamServerManager* s5bServerManager;

+ };

+ class SWIFTEN_API FileTransferOptions {

+ public:

+ FileTransferOptions() : allowInBand_(true), allowAssisted_(true), allowProxied_(true), allowDirect_(true) {

+ }

+ SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(FileTransferOptions)

+ ~FileTransferOptions();

+ FileTransferOptions& withInBandAllowed(bool b) {

+ allowInBand_ = b;

+ return *this;

+ }

+ bool isInBandAllowed() const {

+ return allowInBand_;

+ }

+ FileTransferOptions& withAssistedAllowed(bool b) {

+ allowAssisted_ = b;

+ return *this;

+ }

+ bool isAssistedAllowed() const {

+ return allowAssisted_;

+ }

+ FileTransferOptions& withProxiedAllowed(bool b) {

+ allowProxied_ = b;

+ return *this;

+ }

+ bool isProxiedAllowed() const {

+ return allowProxied_;

+ }

+ FileTransferOptions& withDirectAllowed(bool b) {

+ allowDirect_ = b;

+ return *this;

+ }

+ bool isDirectAllowed() const {

+ return allowDirect_;

+ }

+ SWIFTEN_DEFAULT_COPY_ASSIGMNENT_OPERATOR(FileTransferOptions)

+ private:

+ bool allowInBand_;

+ bool allowAssisted_;

+ bool allowProxied_;

+ bool allowDirect_;

+ };

+ class TransportSession;

+ class ErrorPayload;

+ class ReadBytestream;

+ class WriteBytestream;

+

+ /**

+ * @brief The FileTransferTransporter class is an abstract factory definition

+ * to generate SOCKS5 bytestream transports or IBB bytestreams for use in file

+ * transfers.

+ */

+ class SWIFTEN_API FileTransferTransporter {

+ public:

+ virtual ~FileTransferTransporter();

+

+ virtual void startGeneratingLocalCandidates() = 0;

+ virtual void stopGeneratingLocalCandidates() = 0;

+

+ virtual void addRemoteCandidates(

+ const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string&) = 0;

+ virtual void startTryingRemoteCandidates() = 0;

+ virtual void stopTryingRemoteCandidates() = 0;

+

+ virtual void startActivatingProxy(const JID& proxy) = 0;

+ virtual void stopActivatingProxy() = 0;

+

+ virtual boost::shared_ptr<TransportSession> createIBBSendSession(

+ const std::string& sessionID, unsigned int blockSize, boost::shared_ptr<ReadBytestream>) = 0;

+ virtual boost::shared_ptr<TransportSession> createIBBReceiveSession(

+ const std::string& sessionID, unsigned long long size, boost::shared_ptr<WriteBytestream>) = 0;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession(

+ boost::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) = 0;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession(

+ boost::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) = 0;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession(

+ boost::shared_ptr<ReadBytestream>, const JingleS5BTransportPayload::Candidate& candidate) = 0;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession(

+ boost::shared_ptr<WriteBytestream>, const JingleS5BTransportPayload::Candidate& candidate) = 0;

+

+ boost::signal<void (const std::string& /* sessionID */, const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string& /* dstAddr */)> onLocalCandidatesGenerated;

+ boost::signal<void (const std::string& /* sessionID */, const boost::optional<JingleS5BTransportPayload::Candidate>&)> onRemoteCandidateSelectFinished;

+ boost::signal<void (const std::string& /* sessionID */, boost::shared_ptr<ErrorPayload>)> onProxyActivated;

+ };

+ class JID;

+ class FileTransferTransporter;

+ class FileTransferOptions;

+ class SWIFTEN_API FileTransferTransporterFactory {

+ public:

+ virtual ~FileTransferTransporterFactory();

+ virtual FileTransferTransporter* createInitiatorTransporter(

+ const JID& initiator,

+ const JID& responder,

+ const FileTransferOptions& options) = 0;

+ virtual FileTransferTransporter* createResponderTransporter(

+ const JID& initiator,

+ const JID& responder,

+ const std::string& s5bSessionID,

+ const FileTransferOptions& options) = 0;

+ };

+ if (stream) {

+ stream->close();

+ delete stream;

+ stream = NULL;

+ }

+ if (data.empty()) {

+ return true;

+ }

+ if (!stream) {

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

+ }

+ if (stream->good()) {

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

+ if (stream->good()) {

+ onWrite(data);

+ return true;

+ }

+ }

+ return false;

+ if (stream) {

+ stream->close();

+ delete stream;

+ stream = NULL;

+ }

+ class SWIFTEN_API FileWriteBytestream : public WriteBytestream {

+ public:

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

+ virtual ~FileWriteBytestream();

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

+ void close();

+ private:

+ boost::filesystem::path file;

+ boost::filesystem::ofstream* stream;

+ };

+ public:

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

+ setFinal(false);

+ }

+ 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->bytestream->write(ibb->getData());

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

+ sequenceNumber++;

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

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

+ if (receivedSize > session->size) {

+ SWIFT_LOG(warning) << "Received more data than expected";

+ }

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

+ }

+ }

+ else {

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

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

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

+ }

+ }

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

+ SWIFT_LOG(debug) << "IBB open received";

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

+ }

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

+ SWIFT_LOG(debug) << "IBB close received";

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

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

+ }

+ return true;

+ }

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

+ return false;

+ }

+ private:

+ IBBReceiveSession* session;

+ int sequenceNumber;

+ unsigned long long receivedSize;

+ const std::string& id,

+ const JID& from,

+ const JID& to,

+ unsigned long long size,

+ boost::shared_ptr<WriteBytestream> bytestream,

+ IQRouter* router) :

+ id(id),

+ from(from),

+ to(to),

+ size(size),

+ bytestream(bytestream),

+ router(router),

+ active(false) {

+ assert(!id.empty());

+ assert(from.isValid());

+ responder = new IBBResponder(this, router);

+ if (active) {

+ SWIFT_LOG(warning) << "Session still active";

+ }

+ delete responder;

+ SWIFT_LOG(debug) << "receive session started";

+ active = true;

+ responder->start();

+ SWIFT_LOG(debug) << "receive session stopped";

+ responder->stop();

+ if (active) {

+ if (router->isAvailable()) {

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

+ }

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

+ }

+ active = false;

+ onFinished(error);

+ class IQRouter;

+

+ class SWIFTEN_API IBBReceiveSession {

+ public:

+ IBBReceiveSession(

+ const std::string& id,

+ const JID& from,

+ const JID& to,

+ unsigned long long size,

+ boost::shared_ptr<WriteBytestream> bytestream,

+ IQRouter* router);

+ ~IBBReceiveSession();

+

+ void start();

+ void stop();

+

+ const JID& getSender() const {

+ return from;

+ }

+

+ const JID& getReceiver() const {

+ return to;

+ }

+

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

+

+ private:

+ bool handleSetRequest(const JID& from, const JID& to, const std::string& id, IBB::ref payload);

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

+

+ private:

+ class IBBResponder;

+ friend class IBBResponder;

+

+ std::string id;

+ JID from;

+ JID to;

+ unsigned long long size;

+ boost::shared_ptr<WriteBytestream> bytestream;

+ IQRouter* router;

+ IBBResponder* responder;

+ bool active;

+ };

+ finishedConnection = session->onFinished.connect(boost::bind(boost::ref(onFinished), _1));

+ session->start();

+ session->stop();

+ public:

+ IBBReceiveTransportSession(boost::shared_ptr<IBBReceiveSession> session);

+ virtual ~IBBReceiveTransportSession();

+ virtual void start() SWIFTEN_OVERRIDE;

+ virtual void stop() SWIFTEN_OVERRIDE;

+ private:

+ boost::shared_ptr<IBBReceiveSession> session;

+ boost::bsignals::scoped_connection finishedConnection;

+ boost::bsignals::scoped_connection bytesSentConnection;

+ class SWIFTEN_API IBBRequest : public GenericRequest<IBB> {

+ public:

+ typedef boost::shared_ptr<IBBRequest> ref;

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

+ return ref(new IBBRequest(from, to, payload, router));

+ }

+ private:

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

+ }

+ };

+ const std::string& id,

+ const JID& from,

+ const JID& to,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ IQRouter* router) :

+ id(id),

+ from(from),

+ to(to),

+ bytestream(bytestream),

+ router(router),

+ blockSize(4096),

+ sequenceNumber(0),

+ active(false),

+ waitingForData(false) {

+ bytestream->onDataAvailable.connect(boost::bind(&IBBSendSession::handleDataAvailable, this));

+ bytestream->onDataAvailable.disconnect(boost::bind(&IBBSendSession::handleDataAvailable, this));

+ IBBRequest::ref request = IBBRequest::create(

+ from, to, IBB::createIBBOpen(id, boost::numeric_cast<int>(blockSize)), router);

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

+ active = true;

+ request->send();

+ currentRequest = request;

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

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

+ }

+ if (currentRequest) {

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

+ }

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

+ currentRequest.reset();

+ if (!error && active) {

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

+ sendMoreData();

+ }

+ else {

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

+ }

+ }

+ else {

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

+ }

+ try {

+ boost::shared_ptr<ByteArray> data = bytestream->read(blockSize);

+ if (!data->empty()) {

+ waitingForData = false;

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

+ sequenceNumber++;

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

+ request->send();

+ currentRequest = request;

+ onBytesSent(data->size());

+ }

+ else {

+ waitingForData = true;

+ }

+ }

+ catch (const BytestreamException&) {

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

+ }

+ active = false;

+ onFinished(error);

+ if (waitingForData) {

+ sendMoreData();

+ }

+ class IQRouter;

+ class IBBRequest;

+ class SWIFTEN_API IBBSendSession {

+ public:

+ IBBSendSession(

+ const std::string& id,

+ const JID& from,

+ const JID& to,

+ boost::shared_ptr<ReadBytestream> bytestream,

+ IQRouter* router);

+ ~IBBSendSession();

+ void start();

+ void stop();

+ const JID& getSender() const {

+ return from;

+ }

+ const JID& getReceiver() const {

+ return to;

+ }

+ void setBlockSize(unsigned int blockSize) {

+ this->blockSize = blockSize;

+ }

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

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

+ private:

+ void handleIBBResponse(IBB::ref, ErrorPayload::ref);

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

+ void sendMoreData();

+ void handleDataAvailable();

+ private:

+ std::string id;

+ JID from;

+ JID to;

+ boost::shared_ptr<ReadBytestream> bytestream;

+ IQRouter* router;

+ unsigned int blockSize;

+ int sequenceNumber;

+ bool active;

+ bool waitingForData;

+ boost::shared_ptr<IBBRequest> currentRequest;

+ };

+ finishedConnection = session->onFinished.connect(boost::bind(boost::ref(onFinished), _1));

+ bytesSentConnection = session->onBytesSent.connect(boost::bind(boost::ref(onBytesSent), _1));

+ session->start();

+ session->stop();

+ public:

+ IBBSendTransportSession(boost::shared_ptr<IBBSendSession> session);

+ virtual ~IBBSendTransportSession();

+ virtual void start() SWIFTEN_OVERRIDE;

+ virtual void stop() SWIFTEN_OVERRIDE;

+ private:

+ boost::shared_ptr<IBBSendSession> session;

+ boost::bsignals::scoped_connection finishedConnection;

+ boost::bsignals::scoped_connection bytesSentConnection;

+ class WriteBytestream;

+ class JID;

+

+ /**

+ * @brief The IncomingFileTransfer abstract class is the general interface in Swiften

+ * for incoming file transfers.

+ */

+ class SWIFTEN_API IncomingFileTransfer : public FileTransfer {

+ public:

+ typedef boost::shared_ptr<IncomingFileTransfer> ref;

+

+ virtual ~IncomingFileTransfer();

+

+ virtual void accept(

+ boost::shared_ptr<WriteBytestream>,

+ const FileTransferOptions& = FileTransferOptions()) = 0;

+

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

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

+ };

+ JingleSessionManager* jingleSessionManager,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto) :

+ jingleSessionManager(jingleSessionManager),

+ transporterFactory(transporterFactory),

+ timerFactory(timerFactory),

+ crypto(crypto) {

+ jingleSessionManager->addIncomingSessionHandler(this);

+ jingleSessionManager->removeIncomingSessionHandler(this);

+ JingleSession::ref session,

+ const std::vector<JingleContentPayload::ref>& contents,

+ const JID& recipient) {

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

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

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

+ if (description) {

+ IncomingJingleFileTransfer::ref transfer = boost::make_shared<IncomingJingleFileTransfer>(

+ recipient, session, content, transporterFactory, timerFactory, crypto);

+ onIncomingFileTransfer(transfer);

+ }

+ else {

+ SWIFT_LOG(warning) << "Received a file-transfer request with no file description.";

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

+ }

+ }

+ else {

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

+ }

+ return true;

+ }

+ else {

+ return false;

+ }

+ class JingleSessionManager;

+ class FileTransferTransporterFactory;

+ class TimerFactory;

+ class CryptoProvider;

+

+ class SWIFTEN_API IncomingFileTransferManager : public IncomingJingleSessionHandler {

+ public:

+ IncomingFileTransferManager(

+ JingleSessionManager* jingleSessionManager,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto);

+ virtual ~IncomingFileTransferManager();

+

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

+

+ private:

+ bool handleIncomingJingleSession(

+ JingleSession::ref session,

+ const std::vector<JingleContentPayload::ref>& contents,

+ const JID& recipient);

+

+ private:

+ JingleSessionManager* jingleSessionManager;

+ FileTransferTransporterFactory* transporterFactory;

+ TimerFactory* timerFactory;

+ CryptoProvider* crypto;

+ };

+ const JID& toJID,

+ JingleSession::ref session,

+ JingleContentPayload::ref content,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto) :

+ JingleFileTransfer(session, toJID, transporterFactory),

+ initialContent(content),

+ crypto(crypto),

+ state(Initial),

+ receivedBytes(0),

+ hashCalculator(NULL) {

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

+ assert(description);

+ JingleFileTransferFileInfo fileInfo = description->getFileInfo();

+ setFileInfo(fileInfo.getName(), fileInfo.getSize(), fileInfo.getDescription());

+ hashes = fileInfo.getHashes();

+

+ waitOnHashTimer = timerFactory->createTimer(5000);

+ waitOnHashTimerTickedConnection = waitOnHashTimer->onTick.connect(

+ boost::bind(&IncomingJingleFileTransfer::handleWaitOnHashTimerTicked, this));

+ if (waitOnHashTimer) {

+ waitOnHashTimer->stop();

+ }

+ delete hashCalculator;

+ hashCalculator = NULL;

+ boost::shared_ptr<WriteBytestream> stream,

+ const FileTransferOptions& options) {

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

+ if (state != Initial) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

+ assert(!this->stream);

+ this->stream = stream;

+ this->options = options;

+

+ assert(!hashCalculator);

+

+ hashCalculator = new IncrementalBytestreamHashCalculator(

+ hashes.find("md5") != hashes.end(), hashes.find("sha-1") != hashes.end(), crypto);

+

+ writeStreamDataReceivedConnection = stream->onWrite.connect(

+ boost::bind(&IncomingJingleFileTransfer::handleWriteStreamDataReceived, this, _1));

+

+ JingleS5BTransportPayload::ref s5bTransport = initialContent->getTransport<JingleS5BTransportPayload>();

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

+ if (s5bTransport) {

+ SWIFT_LOG(debug) << "Got S5B transport as initial payload." << std::endl;

+ setTransporter(transporterFactory->createResponderTransporter(

+ getInitiator(), getResponder(), s5bTransport->getSessionID(), options));

+ transporter->addRemoteCandidates(s5bTransport->getCandidates(), s5bTransport->getDstAddr());

+ setState(GeneratingInitialLocalCandidates);

+ transporter->startGeneratingLocalCandidates();

+ }

+ else if (ibbTransport && options.isInBandAllowed()) {

+ SWIFT_LOG(debug) << "Got IBB transport as initial payload." << std::endl;

+ setTransporter(transporterFactory->createResponderTransporter(

+ getInitiator(), getResponder(), ibbTransport->getSessionID(), options));

+

+ startTransferring(transporter->createIBBReceiveSession(

+ ibbTransport->getSessionID(),

+ description->getFileInfo().getSize(),

+ stream));

+

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

+ }

+ else {

+ // This might happen on incoming transfer which only list transport methods we are not allowed to use due to file-transfer options.

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

+ setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));

+ }

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

+ terminate(state == Initial ? JinglePayload::Reason::Decline : JinglePayload::Reason::Cancel);

+ const std::string& s5bSessionID,

+ const std::vector<JingleS5BTransportPayload::Candidate>& candidates,

+ const std::string& dstAddr) {

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

+ if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+ fillCandidateMap(localCandidates, candidates);

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

+ transport->setSessionID(s5bSessionID);

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

+ transport->setDstAddr(dstAddr);

+ foreach(JingleS5BTransportPayload::Candidate candidate, candidates) {

+ transport->addCandidate(candidate);

+ }

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

+ setState(TryingCandidates);

+ transporter->startTryingRemoteCandidates();

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

+

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

+ if (transferHash) {

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

+ waitOnHashTimer->stop();

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

+ hashes["sha-1"] = transferHash->getFileInfo().getHash("sha-1").get();

+ }

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

+ hashes["md5"] = transferHash->getFileInfo().getHash("md5").get();

+ }

+ if (state == WaitingForHash) {

+ checkHashAndTerminate();

+ }

+ }

+ else {

+ SWIFT_LOG(debug) << "Ignoring unknown session info" << std::endl;

+ }

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

+ if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

+ if (state == Finished) {

+ SWIFT_LOG(debug) << "Already terminated" << std::endl;

+ return;

+ }

+

+ stopAll();

+ if (reason && reason->type == JinglePayload::Reason::Cancel) {

+ setFinishedState(FileTransfer::State::Canceled, FileTransferError(FileTransferError::PeerError));

+ }

+ else if (reason && reason->type == JinglePayload::Reason::Success) {

+ setFinishedState(FileTransfer::State::Finished, boost::optional<FileTransferError>());

+ }

+ else {

+ setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));

+ }

+ if (verifyData()) {

+ terminate(JinglePayload::Reason::Success);

+ }

+ else {

+ SWIFT_LOG(warning) << "Hash verification failed" << std::endl;

+ terminate(JinglePayload::Reason::MediaError);

+ }

+ if (receivedBytes == getFileSizeInBytes()) {

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

+ bool hashInfoAvailable = false;

+ foreach(const JingleFileTransferFileInfo::HashElementMap::value_type& hashElement, hashes) {

+ hashInfoAvailable |= !hashElement.second.empty();

+ }

+

+ if (!hashInfoAvailable) {

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

+ setState(WaitingForHash);

+ waitOnHashTimer->start();

+ }

+ else {

+ checkHashAndTerminate();

+ }

+ }

+ else if (receivedBytes > getFileSizeInBytes()) {

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

+ terminate(JinglePayload::Reason::MediaError);

+ }

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

+ hashCalculator->feedData(data);

+ receivedBytes += data.size();

+ onProcessedBytes(data.size());

+ checkIfAllDataReceived();

+ const JingleContentID& content, JingleTransportPayload::ref transport) {

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

+ if (state != WaitingForFallbackOrTerminate) {

+ SWIFT_LOG(warning) << "Incorrect state" << std::endl;

+ return;

+ }

+

+ JingleIBBTransportPayload::ref ibbTransport;

+ if (options.isInBandAllowed() && (ibbTransport = boost::dynamic_pointer_cast<JingleIBBTransportPayload>(transport))) {

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

+

+ startTransferring(transporter->createIBBReceiveSession(

+ ibbTransport->getSessionID(),

+ description->getFileInfo().getSize(),

+ stream));

+ session->sendTransportAccept(content, ibbTransport);

+ }

+ else {

+ SWIFT_LOG(debug) << "Unknown replace transport" << std::endl;

+ session->sendTransportReject(content, transport);

+ }

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

+ if (hashes.empty()) {

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

+ return true;

+ }

+ if (hashes.find("sha-1") != hashes.end()) {

+ SWIFT_LOG(debug) << "Verify SHA-1 hash: " << (hashes["sha-1"] == hashCalculator->getSHA1Hash()) << std::endl;

+ return hashes["sha-1"] == hashCalculator->getSHA1Hash();

+ }

+ else if (hashes.find("md5") != hashes.end()) {

+ SWIFT_LOG(debug) << "Verify MD5 hash: " << (hashes["md5"] == hashCalculator->getMD5Hash()) << std::endl;

+ return hashes["md5"] == hashCalculator->getMD5Hash();

+ }

+ else {

+ SWIFT_LOG(debug) << "Unknown hash, skipping" << std::endl;

+ return true;

+ }

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

+ waitOnHashTimer->stop();

+ terminate(JinglePayload::Reason::Success);

+ return getInitiator();

+ return getResponder();

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

+ this->state = state;

+ onStateChanged(FileTransfer::State(getExternalState(state)));

+ FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {

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

+ this->state = Finished;

+ onStateChanged(type);

+ onFinished(error);

+ if (error && state != WaitingForHash) {

+ terminate(JinglePayload::Reason::MediaError);

+ }

+ switch (state) {

+ case Initial: return FileTransfer::State::Initial;

+ case GeneratingInitialLocalCandidates: return FileTransfer::State::WaitingForStart;

+ case TryingCandidates: return FileTransfer::State::Negotiating;

+ case WaitingForPeerProxyActivate: return FileTransfer::State::Negotiating;

+ case WaitingForLocalProxyActivate: return FileTransfer::State::Negotiating;

+ case WaitingForFallbackOrTerminate: return FileTransfer::State::Negotiating;

+ case Transferring: return FileTransfer::State::Transferring;

+ case WaitingForHash: return FileTransfer::State::Transferring;

+ case Finished: return FileTransfer::State::Finished;

+ }

+ assert(false);

+ return FileTransfer::State::Initial;

+ if (state != Initial) {

+ writeStreamDataReceivedConnection.disconnect();

+ delete hashCalculator;

+ hashCalculator = NULL;

+ }

+ switch (state) {

+ case Initial: break;

+ case GeneratingInitialLocalCandidates: transporter->stopGeneratingLocalCandidates(); break;

+ case TryingCandidates: transporter->stopTryingRemoteCandidates(); break;

+ case WaitingForFallbackOrTerminate: break;

+ case WaitingForPeerProxyActivate: break;

+ case WaitingForLocalProxyActivate: transporter->stopActivatingProxy(); break;

+ case WaitingForHash: // Fallthrough

+ case Transferring:

+ assert(transportSession);

+ transferFinishedConnection.disconnect();

+ transportSession->stop();

+ transportSession.reset();

+ break;

+ case Finished: SWIFT_LOG(warning) << "Already finished" << std::endl; break;

+ }

+ if (state != Initial) {

+ removeTransporter();

+ }

+ return false;

+ setState(WaitingForFallbackOrTerminate);

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

+ if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ setState(WaitingForPeerProxyActivate);

+ }

+ else {

+ startTransferring(createRemoteCandidateSession());

+ }

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

+ if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ setState(WaitingForLocalProxyActivate);

+ transporter->startActivatingProxy(theirCandidateChoice->jid);

+ }

+ else {

+ startTransferring(createLocalCandidateSession());

+ }

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

+ this->transportSession = transportSession;

+ transferFinishedConnection = transportSession->onFinished.connect(

+ boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));

+ setState(Transferring);

+ transportSession->start();

+ return state == WaitingForPeerProxyActivate;

+ return state == WaitingForLocalProxyActivate;

+ return state == TryingCandidates;

+ return transporter->createLocalCandidateSession(stream, theirCandidateChoice.get());

+ return transporter->createRemoteCandidateSession(stream, ourCandidateChoice.get());

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

+ if (state != Finished) {

+ session->sendTerminate(reason);

+ }

+ stopAll();

+ setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));

+ class JID;

+ class JingleSession;

+ class JingleContentPayload;

+ class FileTransferTransporter;

+ class FileTransferTransporterFactory;

+ class TimerFactory;

+ class Timer;

+ class CryptoProvider;

+ class IncrementalBytestreamHashCalculator;

+ class JingleFileTransferDescription;

+ class HashElement;

+

+ /**

+ * @brief The IncomingJingleFileTransfer class contains the business logic for managing incoming

+ * Jingle file transfers.

+ *

+ * Calling IncomingJingleFileTransfer::accept will start to negotiate possible transfer

+ * methods and after a working method has been decided among peers the trasnfer is started.

+ */

+ class SWIFTEN_API IncomingJingleFileTransfer : public IncomingFileTransfer, public JingleFileTransfer {

+ public:

+ typedef boost::shared_ptr<IncomingJingleFileTransfer> ref;

+

+ IncomingJingleFileTransfer(

+ const JID& recipient,

+ boost::shared_ptr<JingleSession>,

+ boost::shared_ptr<JingleContentPayload> content,

+ FileTransferTransporterFactory*,

+ TimerFactory*,

+ CryptoProvider*);

+ virtual ~IncomingJingleFileTransfer();

+

+ virtual void accept(boost::shared_ptr<WriteBytestream>, const FileTransferOptions& = FileTransferOptions()) SWIFTEN_OVERRIDE;

+ virtual void cancel() SWIFTEN_OVERRIDE;

+

+ private:

+ enum State {

+ Initial,

+ GeneratingInitialLocalCandidates,

+ TryingCandidates,

+ WaitingForPeerProxyActivate,

+ WaitingForLocalProxyActivate,

+ WaitingForFallbackOrTerminate,

+ Transferring,

+ WaitingForHash,

+ Finished

+ };

+

+ virtual void handleSessionTerminateReceived(

+ boost::optional<JinglePayload::Reason> reason) SWIFTEN_OVERRIDE;

+ virtual void handleSessionInfoReceived(boost::shared_ptr<JinglePayload>) SWIFTEN_OVERRIDE;

+ virtual void handleTransportReplaceReceived(

+ const JingleContentID&, boost::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

+

+ virtual void handleLocalTransportCandidatesGenerated(

+ const std::string& s5bSessionID,

+ const std::vector<JingleS5BTransportPayload::Candidate>&,

+ const std::string& dstAddr) SWIFTEN_OVERRIDE;

+

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

+ void stopActiveTransport();

+ void checkCandidateSelected();

+ virtual JingleContentID getContentID() const SWIFTEN_OVERRIDE;

+ void checkIfAllDataReceived();

+ bool verifyData();

+ void handleWaitOnHashTimerTicked();

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

+

+ private:

+ virtual void startTransferViaRemoteCandidate() SWIFTEN_OVERRIDE;

+ virtual void startTransferViaLocalCandidate() SWIFTEN_OVERRIDE;

+ void checkHashAndTerminate();

+ void stopAll();

+ void setState(State state);

+ void setFinishedState(FileTransfer::State::Type, const boost::optional<FileTransferError>& error);

+ const JID& getSender() const SWIFTEN_OVERRIDE;

+ const JID& getRecipient() const SWIFTEN_OVERRIDE;

+ static FileTransfer::State::Type getExternalState(State state);

+ virtual bool hasPriorityOnCandidateTie() const SWIFTEN_OVERRIDE;

+ virtual void fallback() SWIFTEN_OVERRIDE;

+ virtual void startTransferring(boost::shared_ptr<TransportSession>) SWIFTEN_OVERRIDE;

+ virtual bool isWaitingForPeerProxyActivate() const SWIFTEN_OVERRIDE;

+ virtual bool isWaitingForLocalProxyActivate() const SWIFTEN_OVERRIDE;

+ virtual bool isTryingCandidates() const SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession() SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession() SWIFTEN_OVERRIDE;

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

+

+

+ private:

+ boost::shared_ptr<JingleContentPayload> initialContent;

+ CryptoProvider* crypto;

+ State state;

+ boost::shared_ptr<JingleFileTransferDescription> description;

+ boost::shared_ptr<WriteBytestream> stream;

+ boost::uintmax_t receivedBytes;

+ IncrementalBytestreamHashCalculator* hashCalculator;

+ boost::shared_ptr<Timer> waitOnHashTimer;

+ std::map<std::string, ByteArray> hashes;

+ FileTransferOptions options;

+

+ boost::bsignals::scoped_connection writeStreamDataReceivedConnection;

+ boost::bsignals::scoped_connection waitOnHashTimerTickedConnection;

+ boost::bsignals::connection transferFinishedConnection;

+ };

+ md5Hasher = doMD5 ? crypto->createMD5() : NULL;

+ sha1Hasher = doSHA1 ? crypto->createSHA1() : NULL;

+ delete md5Hasher;

+ delete sha1Hasher;

+ if (md5Hasher) {

+ md5Hasher->update(data);

+ }

+ if (sha1Hasher) {

+ sha1Hasher->update(data);

+ }

+ if (md5Hasher) {

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

+ }

+ if (sha1Hasher) {

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

+ }

+ assert(sha1Hasher);

+ if (!sha1Hash) {

+ sha1Hash = sha1Hasher->getHash();

+ }

+ return *sha1Hash;

+ assert(md5Hasher);

+ if (!md5Hash) {

+ md5Hash = md5Hasher->getHash();

+ }

+ return *md5Hash;

+ assert(sha1Hasher);

+ return Hexify::hexify(getSHA1Hash());;

+ assert(md5Hasher);

+ return Hexify::hexify(getMD5Hash());;

+ class Hash;

+ class CryptoProvider;

+ class IncrementalBytestreamHashCalculator {

+ public:

+ IncrementalBytestreamHashCalculator(bool doMD5, bool doSHA1, CryptoProvider* crypto);

+ ~IncrementalBytestreamHashCalculator();

+ void feedData(const ByteArray& data);

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

+ ByteArray getSHA1Hash();

+ ByteArray getMD5Hash();

+ std::string getSHA1String();

+ std::string getMD5String();

+ private:

+ Hash* md5Hasher;

+ Hash* sha1Hasher;

+ boost::optional<ByteArray> md5Hash;

+ boost::optional<ByteArray> sha1Hash;

+ };

+ boost::shared_ptr<JingleSession> session,

+ const JID& target,

+ FileTransferTransporterFactory* transporterFactory) :

+ session(session),

+ target(target),

+ transporterFactory(transporterFactory),

+ transporter(NULL),

+ ourCandidateSelectFinished(false),

+ theirCandidateSelectFinished(false) {

+

+ session->addListener(this);

+ session->removeListener(this);

+ map.clear();

+ foreach (JingleS5BTransportPayload::Candidate candidate, candidates) {

+ map[candidate.cid] = candidate;

+ }

+ return Hexify::hexify(crypto->getSHA1Hash(

+ createSafeByteArray(s5bSessionID + requester.toString() + target.toString())));

+ return session->getInitiator();

+ return target;

+ if (reason == JinglePayload::Reason::Cancel || reason == JinglePayload::Reason::Decline) {

+ return FileTransfer::State::Canceled;

+ }

+ else if (reason == JinglePayload::Reason::Success) {

+ return FileTransfer::State::Finished;

+ }

+ else {

+ return FileTransfer::State::Failed;

+ }

+ if (reason == JinglePayload::Reason::Success) {

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

+ }

+ else {

+ return boost::optional<FileTransferError>(FileTransferError::UnknownError);

+ }

+ const std::string& s5bSessionID, const boost::optional<JingleS5BTransportPayload::Candidate>& candidate) {

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

+

+ ourCandidateChoice = candidate;

+ ourCandidateSelectFinished = true;

+

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

+ s5bPayload->setSessionID(s5bSessionID);

+ if (candidate) {

+ s5bPayload->setCandidateUsed(candidate->cid);

+ }

+ else {

+ s5bPayload->setCandidateError(true);

+ }

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

+

+ decideOnCandidates();

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

+ if (!ourCandidateSelectFinished || !theirCandidateSelectFinished) {

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

+ return;

+ }

+ if (!ourCandidateChoice && !theirCandidateChoice) {

+ SWIFT_LOG(debug) << "No candidates succeeded." << std::endl;

+ fallback();

+ }

+ else if (ourCandidateChoice && !theirCandidateChoice) {

+ SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << "." << std::endl;

+ startTransferViaRemoteCandidate();

+ }

+ else if (theirCandidateChoice && !ourCandidateChoice) {

+ SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid << "." << std::endl;

+ startTransferViaLocalCandidate();

+ }

+ else {

+ SWIFT_LOG(debug) << "Choosing between candidates "

+ << ourCandidateChoice->cid << "(" << ourCandidateChoice->priority << ")" << " and "

+ << theirCandidateChoice->cid << "(" << theirCandidateChoice->priority << ")" << std::endl;

+ if (ourCandidateChoice->priority > theirCandidateChoice->priority) {

+ SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << "." << std::endl;

+ startTransferViaRemoteCandidate();

+ }

+ else if (ourCandidateChoice->priority < theirCandidateChoice->priority) {

+ SWIFT_LOG(debug) << "Start transfer using local candidate:" << theirCandidateChoice.get().cid << "." << std::endl;

+ startTransferViaLocalCandidate();

+ }

+ else {

+ if (hasPriorityOnCandidateTie()) {

+ SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << std::endl;

+ startTransferViaRemoteCandidate();

+ }

+ else {

+ SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid << std::endl;

+ startTransferViaLocalCandidate();

+ }

+ }

+ }

+ const std::string& s5bSessionID, ErrorPayload::ref error) {

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

+ if (!isWaitingForLocalProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

+ if (error) {

+ SWIFT_LOG(debug) << "Error activating proxy" << std::endl;

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

+ proxyError->setSessionID(s5bSessionID);

+ proxyError->setProxyError(true);

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

+ fallback();

+ }

+ else {

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

+ proxyActivate->setSessionID(s5bSessionID);

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

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

+ startTransferring(createLocalCandidateSession());

+ }

+ const JingleContentID& /* contentID */, JingleTransportPayload::ref transport) {

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

+

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

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

+ SWIFT_LOG(debug) << "Received candidate decision from peer" << std::endl;

+ if (!isTryingCandidates()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

+ theirCandidateSelectFinished = true;

+ if (!s5bPayload->hasCandidateError()) {

+ BOOST_AUTO(theirCandidate, localCandidates.find(s5bPayload->getCandidateUsed()));

+ if (theirCandidate == localCandidates.end()) {

+ SWIFT_LOG(warning) << "Got invalid candidate" << std::endl;

+ terminate(JinglePayload::Reason::GeneralError);

+ return;

+ }

+ theirCandidateChoice = theirCandidate->second;

+ }

+ decideOnCandidates();

+ }

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

+ SWIFT_LOG(debug) << "Received peer activate from peer" << std::endl;

+ if (!isWaitingForPeerProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

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

+ startTransferring(createRemoteCandidateSession());

+ }

+ else {

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

+ terminate(JinglePayload::Reason::GeneralError);

+ }

+ }

+ else if (s5bPayload->hasProxyError()) {

+ SWIFT_LOG(debug) << "Received proxy error. Trying to fall back to IBB." << std::endl;

+ fallback();

+ }

+ else {

+ SWIFT_LOG(debug) << "Ignoring unknown info" << std::endl;

+ }

+ }

+ else {

+ SWIFT_LOG(debug) << "Ignoring unknown info" << std::endl;

+ }

+ SWIFT_LOG_ASSERT(!this->transporter, error);

+ this->transporter = transporter;

+ localTransportCandidatesGeneratedConnection = transporter->onLocalCandidatesGenerated.connect(

+ boost::bind(&JingleFileTransfer::handleLocalTransportCandidatesGenerated, this, _1, _2, _3));

+ remoteTransportCandidateSelectFinishedConnection = transporter->onRemoteCandidateSelectFinished.connect(

+ boost::bind(&JingleFileTransfer::handleRemoteTransportCandidateSelectFinished, this, _1, _2));

+ proxyActivatedConnection = transporter->onProxyActivated.connect(

+ boost::bind(&JingleFileTransfer::handleProxyActivateFinished, this, _1, _2));

+ if (transporter) {

+ localTransportCandidatesGeneratedConnection.release();

+ remoteTransportCandidateSelectFinishedConnection.release();

+ proxyActivatedConnection.release();

+ delete transporter;

+ transporter = NULL;

+ }

+ class CryptoProvider;

+ class IQRouter;

+ class RemoteJingleTransportCandidateSelector;

+ class LocalJingleTransportCandidateGenerator;

+ class JingleSession;

+ class FileTransferTransporter;

+ class FileTransferTransporterFactory;

+ class TransportSession;

+ class SWIFTEN_API JingleFileTransfer : public AbstractJingleSessionListener {

+ public:

+ JingleFileTransfer(

+ boost::shared_ptr<JingleSession>,

+ const JID& target,

+ FileTransferTransporterFactory*);

+ virtual ~JingleFileTransfer();

+ protected:

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

+ virtual void handleLocalTransportCandidatesGenerated(

+ const std::string& s5bSessionID,

+ const std::vector<JingleS5BTransportPayload::Candidate>&,

+ const std::string& dstAddr) = 0;

+ virtual void handleProxyActivateFinished(

+ const std::string& s5bSessionID,

+ ErrorPayload::ref error);

+ virtual void decideOnCandidates();

+ void handleRemoteTransportCandidateSelectFinished(

+ const std::string& s5bSessionID, const boost::optional<JingleS5BTransportPayload::Candidate>&);

+ virtual JingleContentID getContentID() const = 0;

+ virtual void startTransferring(boost::shared_ptr<TransportSession>) = 0;

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

+ virtual void fallback() = 0;

+ virtual bool hasPriorityOnCandidateTie() const = 0;

+ virtual bool isWaitingForPeerProxyActivate() const = 0;

+ virtual bool isWaitingForLocalProxyActivate() const = 0;

+ virtual bool isTryingCandidates() const = 0;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession() = 0;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession() = 0;

+ virtual void startTransferViaLocalCandidate() = 0;

+ virtual void startTransferViaRemoteCandidate() = 0;

+ protected:

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

+ void setTransporter(FileTransferTransporter* transporter);

+ void removeTransporter();

+ void fillCandidateMap(

+ CandidateMap& map,

+ const std::vector<JingleS5BTransportPayload::Candidate>&);

+ const JID& getInitiator() const;

+ const JID& getResponder() const;

+ static FileTransfer::State::Type getExternalFinishedState(JinglePayload::Reason::Type);

+ static boost::optional<FileTransferError> getFileTransferError(JinglePayload::Reason::Type);

+ boost::shared_ptr<JingleSession> session;

+ JID target;

+ FileTransferTransporterFactory* transporterFactory;

+ FileTransferTransporter* transporter;

+ std::string candidateSelectRequestID;

+ bool ourCandidateSelectFinished;

+ boost::optional<JingleS5BTransportPayload::Candidate> ourCandidateChoice;

+ bool theirCandidateSelectFinished;

+ boost::optional<JingleS5BTransportPayload::Candidate> theirCandidateChoice;

+ CandidateMap localCandidates;

+ boost::shared_ptr<TransportSession> transportSession;

+ boost::bsignals::scoped_connection localTransportCandidatesGeneratedConnection;

+ boost::bsignals::scoped_connection remoteTransportCandidateSelectFinishedConnection;

+ boost::bsignals::scoped_connection proxyActivatedConnection;

+ };

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxy,

+ const JID& ownJID,

+ IDGenerator* idGenerator,

+ const FileTransferOptions& options) :

+ s5bServerManager(s5bServerManager),

+ s5bProxy(s5bProxy),

+ ownJID(ownJID),

+ idGenerator(idGenerator),

+ triedServerInit_(false),

+ triedForwarding_(false),

+ triedProxyDiscovery_(false),

+ options_(options) {

+ SWIFT_LOG_ASSERT(!s5bServerInitializeRequest, warning) << std::endl;

+ assert(!s5bServerInitializeRequest);

+ if (options_.isDirectAllowed() || options_.isAssistedAllowed()) {

+ s5bServerResourceUser_ = s5bServerManager->aquireResourceUser();

+ if (s5bServerResourceUser_->isInitialized()) {

+ handleS5BServerInitialized(true);

+ }

+ else {

+ s5bServerResourceUser_->onSuccessfulInitialized.connect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));

+ }

+ } else {

+ handleS5BServerInitialized(false);

+ }

+

+ if (options_.isProxiedAllowed()) {

+ s5bProxy->onDiscoveredProxiesChanged.connect(boost::bind(&LocalJingleTransportCandidateGenerator::handleDiscoveredProxiesChanged, this));

+ if (s5bProxy->getOrDiscoverS5BProxies().is_initialized()) {

+ handleDiscoveredProxiesChanged();

+ }

+ }

+ s5bProxy->onDiscoveredProxiesChanged.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleDiscoveredProxiesChanged, this));

+ if (s5bServerPortForwardingUser_) {

+ s5bServerPortForwardingUser_->onSetup.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handlePortForwardingSetup, this, _1));

+ s5bServerPortForwardingUser_.reset();

+ }

+ if (s5bServerResourceUser_) {

+ s5bServerResourceUser_->onSuccessfulInitialized.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));

+ s5bServerResourceUser_.reset();

+ }

+ if (s5bServerResourceUser_) {

+ s5bServerResourceUser_->onSuccessfulInitialized.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));

+ }

+ triedServerInit_ = true;

+ if (success) {

+ if (options_.isAssistedAllowed()) {

+ // try to setup port forwarding

+ s5bServerPortForwardingUser_ = s5bServerManager->aquirePortForwardingUser();

+ s5bServerPortForwardingUser_->onSetup.connect(boost::bind(&LocalJingleTransportCandidateGenerator::handlePortForwardingSetup, this, _1));

+ if (s5bServerPortForwardingUser_->isForwardingSetup()) {

+ handlePortForwardingSetup(true);

+ }

+ }

+ }

+ else {

+ SWIFT_LOG(warning) << "Unable to start SOCKS5 server" << std::endl;

+ if (s5bServerResourceUser_) {

+ s5bServerResourceUser_->onSuccessfulInitialized.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));

+ }

+ s5bServerResourceUser_.reset();

+ handlePortForwardingSetup(false);

+ }

+ checkS5BCandidatesReady();

+ if (s5bServerPortForwardingUser_) {

+ s5bServerPortForwardingUser_->onSetup.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handlePortForwardingSetup, this, _1));

+ }

+ triedForwarding_ = true;

+ checkS5BCandidatesReady();

+ if (s5bProxy) {

+ s5bProxy->onDiscoveredProxiesChanged.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleDiscoveredProxiesChanged, this));

+ }

+ triedProxyDiscovery_ = true;

+ checkS5BCandidatesReady();

+ if ((!options_.isDirectAllowed() || (options_.isDirectAllowed() && triedServerInit_)) &&

+ (!options_.isProxiedAllowed() || (options_.isProxiedAllowed() && triedProxyDiscovery_)) &&

+ (!options_.isAssistedAllowed() || (options_.isAssistedAllowed() && triedForwarding_))) {

+ emitOnLocalTransportCandidatesGenerated();

+ }

+ std::vector<JingleS5BTransportPayload::Candidate> candidates;

+

+ if (options_.isDirectAllowed()) {

+ // get direct candidates

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

+ foreach(HostAddressPort addressPort, directCandidates) {

+ if (addressPort.getAddress().getRawAddress().is_v6() &&

+ addressPort.getAddress().getRawAddress().to_v6().is_link_local()) {

+ continue;

+ }

+ JingleS5BTransportPayload::Candidate candidate;

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

+ candidate.jid = ownJID;

+ candidate.hostPort = addressPort;

+ candidate.priority = 65536 * 126 + LOCAL_PREFERENCE;

+ candidate.cid = idGenerator->generateID();

+ candidates.push_back(candidate);

+ }

+ }

+

+ if (options_.isAssistedAllowed()) {

+ // get assissted candidates

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

+ foreach(HostAddressPort addressPort, assisstedCandidates) {

+ JingleS5BTransportPayload::Candidate candidate;

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

+ candidate.jid = ownJID;

+ candidate.hostPort = addressPort;

+ candidate.priority = 65536 * 120 + LOCAL_PREFERENCE;

+ candidate.cid = idGenerator->generateID();

+ candidates.push_back(candidate);

+ }

+ }

+

+ if (options_.isProxiedAllowed() && s5bProxy->getOrDiscoverS5BProxies().is_initialized()) {

+ foreach(S5BProxyRequest::ref proxy, s5bProxy->getOrDiscoverS5BProxies().get()) {

+ if (proxy->getStreamHost()) { // FIXME: Added this test, because there were cases where this wasn't initialized. Investigate this. (Remko)

+ JingleS5BTransportPayload::Candidate candidate;

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

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

+ HostAddress address = (*proxy->getStreamHost()).host;

+ assert(address.isValid());

+ candidate.hostPort = HostAddressPort(address, (*proxy->getStreamHost()).port);

+ candidate.priority = 65536 * 10 + LOCAL_PREFERENCE;

+ candidate.cid = idGenerator->generateID();

+ candidates.push_back(candidate);

+ }

+ }

+ }

+

+ onLocalTransportCandidatesGenerated(candidates);

+ class SOCKS5BytestreamServerManager;

+ class SOCKS5BytestreamProxiesManager;

+ class SOCKS5BytestreamServerInitializeRequest;

+ class SOCKS5BytestreamServerResourceUser;

+ class SOCKS5BytestreamServerPortForwardingUser;

+ class JingleS5BTransportPayload;

+ class LocalJingleTransportCandidateGenerator {

+ public:

+ LocalJingleTransportCandidateGenerator(

+ SOCKS5BytestreamServerManager* s5bServerManager,

+ SOCKS5BytestreamProxiesManager* s5bProxy,

+ const JID& ownJID,

+ IDGenerator* idGenerator,

+ const FileTransferOptions& options);

+ virtual ~LocalJingleTransportCandidateGenerator();

+ virtual void start();

+ virtual void stop();

+ boost::signal<void (const std::vector<JingleS5BTransportPayload::Candidate>&)> onLocalTransportCandidatesGenerated;

+ private:

+ void handleS5BServerInitialized(bool success);

+ void handlePortForwardingSetup(bool success);

+ void handleDiscoveredProxiesChanged();

+ void checkS5BCandidatesReady();

+ void emitOnLocalTransportCandidatesGenerated();

+ private:

+ SOCKS5BytestreamServerManager* s5bServerManager;

+ SOCKS5BytestreamProxiesManager* s5bProxy;

+ JID ownJID;

+ IDGenerator* idGenerator;

+ boost::shared_ptr<SOCKS5BytestreamServerInitializeRequest> s5bServerInitializeRequest;

+ boost::shared_ptr<SOCKS5BytestreamServerResourceUser> s5bServerResourceUser_;

+ boost::shared_ptr<SOCKS5BytestreamServerPortForwardingUser> s5bServerPortForwardingUser_;

+ bool triedServerInit_;

+ bool triedForwarding_;

+ bool triedProxyDiscovery_;

+ FileTransferOptions options_;

+ };

+ class SWIFTEN_API OutgoingFileTransfer : public FileTransfer {

+ public:

+ typedef boost::shared_ptr<OutgoingFileTransfer> ref;

+ public:

+ virtual ~OutgoingFileTransfer();

+ virtual void start() = 0;

+ };

+ JingleSessionManager* jingleSessionManager,

+ IQRouter* router,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto) :

+ jingleSessionManager(jingleSessionManager),

+ iqRouter(router),

+ transporterFactory(transporterFactory),

+ timerFactory(timerFactory),

+ crypto(crypto) {

+ idGenerator = new IDGenerator();

+ delete idGenerator;

+ const JID& from,

+ const JID& recipient,

+ boost::shared_ptr<ReadBytestream> readBytestream,

+ const JingleFileTransferFileInfo& fileInfo,

+ const FileTransferOptions& config) {

+ JingleSessionImpl::ref jingleSession = boost::make_shared<JingleSessionImpl>(

+ from, recipient, idGenerator->generateID(), iqRouter);

+ jingleSessionManager->registerOutgoingSession(from, jingleSession);

+ return boost::shared_ptr<OutgoingJingleFileTransfer>(new OutgoingJingleFileTransfer(

+ recipient,

+ jingleSession,

+ readBytestream,

+ transporterFactory,

+ timerFactory,

+ idGenerator,

+ fileInfo,

+ config,

+ crypto));

+ class JingleSessionManager;

+ class IQRouter;

+ class FileTransferTransporterFactory;

+ class OutgoingFileTransfer;

+ class JID;

+ class IDGenerator;

+ class ReadBytestream;

+ class JingleFileTransferFileInfo;

+ class CryptoProvider;

+ class FileTransferOptions;

+ class TimerFactory;

+

+ class SWIFTEN_API OutgoingFileTransferManager {

+ public:

+ OutgoingFileTransferManager(

+ JingleSessionManager* jingleSessionManager,

+ IQRouter* router,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ CryptoProvider* crypto);

+ ~OutgoingFileTransferManager();

+

+ boost::shared_ptr<OutgoingFileTransfer> createOutgoingFileTransfer(

+ const JID& from,

+ const JID& to,

+ boost::shared_ptr<ReadBytestream>,

+ const JingleFileTransferFileInfo&,

+ const FileTransferOptions&);

+

+ private:

+ JingleSessionManager* jingleSessionManager;

+ IQRouter* iqRouter;

+ FileTransferTransporterFactory* transporterFactory;

+ TimerFactory* timerFactory;

+ IDGenerator* idGenerator;

+ CryptoProvider* crypto;

+ };

+// TODO:

+ const JID& toJID,

+ JingleSession::ref session,

+ boost::shared_ptr<ReadBytestream> stream,

+ FileTransferTransporterFactory* transporterFactory,

+ TimerFactory* timerFactory,

+ IDGenerator* idGenerator,

+ const JingleFileTransferFileInfo& fileInfo,

+ const FileTransferOptions& options,

+ CryptoProvider* crypto) :

+ JingleFileTransfer(session, toJID, transporterFactory),

+ idGenerator(idGenerator),

+ stream(stream),

+ fileInfo(fileInfo),

+ options(options),

+ contentID(idGenerator->generateID(), JingleContentPayload::InitiatorCreator),

+ state(Initial),

+ candidateAcknowledged(false) {

+

+ setFileInfo(fileInfo.getName(), fileInfo.getSize(), fileInfo.getDescription());

+

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

+ hashCalculator = new IncrementalBytestreamHashCalculator(true, true, crypto);

+ stream->onRead.connect(

+ boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+

+ waitForRemoteTermination = timerFactory->createTimer(5000);

+ waitForRemoteTermination->onTick.connect(boost::bind(&OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout, this));

+ if (waitForRemoteTermination) {

+ waitForRemoteTermination->onTick.disconnect(boost::bind(&OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout, this));

+ waitForRemoteTermination->stop();

+ }

+

+ stream->onRead.disconnect(

+ boost::bind(&IncrementalBytestreamHashCalculator::feedData, hashCalculator, _1));

+ delete hashCalculator;

+ hashCalculator = NULL;

+ removeTransporter();

+

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

+ if (state != Initial) {

+ SWIFT_LOG(warning) << "Incorrect state" << std::endl;

+ return;

+ }

+

+ if (!options.isInBandAllowed() && !options.isDirectAllowed() && !options.isAssistedAllowed() && !options.isProxiedAllowed()) {

+ // Started outgoing file transfer while not supporting transport methods.

+ setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::UnknownError));

+ }

+ else {

+ setTransporter(transporterFactory->createInitiatorTransporter(getInitiator(), getResponder(), options));

+ setInternalState(GeneratingInitialLocalCandidates);

+ transporter->startGeneratingLocalCandidates();

+ }

+ terminate(JinglePayload::Reason::Cancel);

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

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

+ session->sendTerminate(reason);

+ }

+ stopAll();

+ setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));

+ const JingleContentID&,

+ JingleDescription::ref,

+ JingleTransportPayload::ref transportPayload) {

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

+ if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

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

+ transporter->addRemoteCandidates(s5bPayload->getCandidates(), s5bPayload->getDstAddr());

+ setInternalState(TryingCandidates);

+ transporter->startTryingRemoteCandidates();

+ }

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

+ startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));

+ }

+ else {

+ SWIFT_LOG(debug) << "Unknown transport payload. Falling back." << std::endl;

+ fallback();

+ }

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

+ if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }

+

+ stopAll();

+ if (state == WaitForTermination) {

+ waitForRemoteTermination->stop();

+ }

+ if (reason && reason->type == JinglePayload::Reason::Cancel) {

+ setFinishedState(FileTransfer::State::Canceled, FileTransferError(FileTransferError::PeerError));

+ }

+ else if (reason && reason->type == JinglePayload::Reason::Decline) {

+ setFinishedState(FileTransfer::State::Canceled, boost::optional<FileTransferError>());

+ }

+ else if (reason && reason->type == JinglePayload::Reason::Success) {

+ setFinishedState(FileTransfer::State::Finished, boost::optional<FileTransferError>());

+ }

+ else {

+ setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));

+ }

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

+ if (state != FallbackRequested) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }

+

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

+ startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));

+ }

+ else {

+ SWIFT_LOG(debug) << "Unknown transport replacement" << std::endl;

+ terminate(JinglePayload::Reason::FailedTransport);

+ }

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

+ terminate(JinglePayload::Reason::UnsupportedTransports);

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

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

+ hashElement->getFileInfo().addHash(HashElement("sha-1", hashCalculator->getSHA1Hash()));

+ hashElement->getFileInfo().addHash(HashElement("md5", hashCalculator->getMD5Hash()));

+ session->sendInfo(hashElement);

+ const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>& candidates, const std::string& dstAddr) {

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

+ if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }

+

+ fillCandidateMap(localCandidates, candidates);

+

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

+ fileInfo.addHash(HashElement("sha-1", ByteArray()));

+ fileInfo.addHash(HashElement("md5", ByteArray()));

+ description->setFileInfo(fileInfo);

+

+ JingleTransportPayload::ref transport;

+ if (candidates.empty()) {

+ SWIFT_LOG(debug) << "no S5B candidates generated. Send IBB transport candidate." << std::endl;

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

+ ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

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

+ transport = ibbTransport;

+ }

+ else {

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

+ s5bTransport->setSessionID(s5bSessionID);

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

+ s5bTransport->setDstAddr(dstAddr);

+ foreach(JingleS5BTransportPayload::Candidate candidate, candidates) {

+ s5bTransport->addCandidate(candidate);

+ SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString() << std::endl;

+ }

+ transport = s5bTransport;

+ }

+ setInternalState(WaitingForAccept);

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

+ if (options.isInBandAllowed()) {

+ SWIFT_LOG(debug) << "Trying to fallback to IBB transport." << std::endl;

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

+ ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

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

+ setInternalState(FallbackRequested);

+ session->sendTransportReplace(contentID, ibbTransport);

+ }

+ else {

+ SWIFT_LOG(debug) << "Fallback to IBB transport not allowed." << std::endl;

+ terminate(JinglePayload::Reason::ConnectivityError);

+ }

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

+ if (state != Transferring) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }

+

+ if (error) {

+ terminate(JinglePayload::Reason::ConnectivityError);

+ }

+ else {

+ sendSessionInfoHash();

+

+ // wait for other party to terminate session after they have verified the hash

+ setInternalState(WaitForTermination);

+ waitForRemoteTermination->start();

+ }

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

+

+ this->transportSession = transportSession;

+ processedBytesConnection = transportSession->onBytesSent.connect(

+ boost::bind(boost::ref(onProcessedBytes), _1));

+ transferFinishedConnection = transportSession->onFinished.connect(

+ boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));

+ setInternalState(Transferring);

+ transportSession->start();

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

+ this->state = state;

+ setState(FileTransfer::State(getExternalState(state)));

+ FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {

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

+ this->state = Finished;

+ onStateChanged(type);

+ onFinished(error);

+ switch (state) {

+ case Initial: return FileTransfer::State::Initial;

+ case GeneratingInitialLocalCandidates: return FileTransfer::State::WaitingForStart;

+ case WaitingForAccept: return FileTransfer::State::WaitingForAccept;

+ case TryingCandidates: return FileTransfer::State::Negotiating;

+ case WaitingForPeerProxyActivate: return FileTransfer::State::Negotiating;

+ case WaitingForLocalProxyActivate: return FileTransfer::State::Negotiating;

+ case WaitingForCandidateAcknowledge: return FileTransfer::State::Negotiating;

+ case FallbackRequested: return FileTransfer::State::Negotiating;

+ case Transferring: return FileTransfer::State::Transferring;

+ case WaitForTermination: return FileTransfer::State::Transferring;

+ case Finished: return FileTransfer::State::Finished;

+ }

+ assert(false);

+ return FileTransfer::State::Initial;

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

+ switch (state) {

+ case Initial: SWIFT_LOG(warning) << "Not yet started" << std::endl; break;

+ case GeneratingInitialLocalCandidates: transporter->stopGeneratingLocalCandidates(); break;

+ case WaitingForAccept: break;

+ case TryingCandidates: transporter->stopTryingRemoteCandidates(); break;

+ case FallbackRequested: break;

+ case WaitingForPeerProxyActivate: break;

+ case WaitingForLocalProxyActivate: transporter->stopActivatingProxy(); break;

+ case WaitingForCandidateAcknowledge: // Fallthrough

+ case Transferring:

+ assert(transportSession);

+ processedBytesConnection.disconnect();

+ transferFinishedConnection.disconnect();

+ transportSession->stop();

+ transportSession.reset();

+ break;

+ case WaitForTermination:

+ break;

+ case Finished: SWIFT_LOG(warning) << "Already finished" << std::endl; break;

+ }

+ if (state != Initial) {

+ removeTransporter();

+ }

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

+

+ if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ setInternalState(WaitingForPeerProxyActivate);

+ }

+ else {

+ transportSession = createRemoteCandidateSession();

+ startTransferringIfCandidateAcknowledged();

+ }

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

+

+ if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {

+ setInternalState(WaitingForLocalProxyActivate);

+ transporter->startActivatingProxy(theirCandidateChoice->jid);

+ }

+ else {

+ transportSession = createLocalCandidateSession();

+ startTransferringIfCandidateAcknowledged();

+ }

+ if (candidateAcknowledged) {

+ startTransferring(transportSession);

+ }

+ else {

+ setInternalState(WaitingForCandidateAcknowledge);

+ }

+ if (id == candidateSelectRequestID) {

+ candidateAcknowledged = true;

+ }

+ if (state == WaitingForCandidateAcknowledge) {

+ startTransferring(transportSession);

+ }

+ return contentID;

+ return true;

+ return state == WaitingForPeerProxyActivate;

+ return state == WaitingForLocalProxyActivate;

+ return state == TryingCandidates;

+ return transporter->createLocalCandidateSession(stream, theirCandidateChoice.get());

+ return transporter->createRemoteCandidateSession(stream, ourCandidateChoice.get());

+ assert(state == WaitForTermination);

+ SWIFT_LOG(warning) << "Other party did not terminate session. Terminate it now." << std::endl;

+ waitForRemoteTermination->stop();

+ terminate(JinglePayload::Reason::MediaError);

+ class CryptoProvider;

+ class FileTransferTransporter;

+ class FileTransferTransporterFactory;

+ class IDGenerator;

+ class IncrementalBytestreamHashCalculator;

+ class ReadBytestream;

+ class TimerFactory;

+ class TransportSession;

+

+ class SWIFTEN_API OutgoingJingleFileTransfer : public OutgoingFileTransfer, public JingleFileTransfer {

+ public:

+ OutgoingJingleFileTransfer(

+ const JID& to,

+ boost::shared_ptr<JingleSession>,

+ boost::shared_ptr<ReadBytestream>,

+ FileTransferTransporterFactory*,

+ TimerFactory*,

+ IDGenerator*,

+ const JingleFileTransferFileInfo&,

+ const FileTransferOptions&,

+ CryptoProvider*);

+ virtual ~OutgoingJingleFileTransfer();

+

+ virtual void start() SWIFTEN_OVERRIDE;

+ virtual void cancel() SWIFTEN_OVERRIDE;

+

+ private:

+ enum State {

+ Initial,

+ GeneratingInitialLocalCandidates,

+ WaitingForAccept,

+ TryingCandidates,

+ WaitingForPeerProxyActivate,

+ WaitingForLocalProxyActivate,

+ WaitingForCandidateAcknowledge,

+ FallbackRequested,

+ Transferring,

+ WaitForTermination,

+ Finished

+ };

+

+ virtual void handleSessionAcceptReceived(const JingleContentID&, boost::shared_ptr<JingleDescription>, boost::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

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

+ virtual void handleTransportAcceptReceived(const JingleContentID&, boost::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

+ virtual void handleTransportRejectReceived(const JingleContentID &, boost::shared_ptr<JingleTransportPayload>) SWIFTEN_OVERRIDE;

+ virtual void startTransferViaRemoteCandidate() SWIFTEN_OVERRIDE;

+ virtual void startTransferViaLocalCandidate() SWIFTEN_OVERRIDE;

+ void startTransferringIfCandidateAcknowledged();

+

+ virtual void handleLocalTransportCandidatesGenerated(const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string& dstAddr) SWIFTEN_OVERRIDE;

+ virtual void handleTransportInfoAcknowledged(const std::string& id) SWIFTEN_OVERRIDE;

+

+ virtual JingleContentID getContentID() const SWIFTEN_OVERRIDE;

+

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

+

+ virtual void fallback() SWIFTEN_OVERRIDE;

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

+

+ void sendSessionInfoHash();

+

+ virtual void startTransferring(boost::shared_ptr<TransportSession>) SWIFTEN_OVERRIDE;

+

+ virtual bool hasPriorityOnCandidateTie() const SWIFTEN_OVERRIDE;

+ virtual bool isWaitingForPeerProxyActivate() const SWIFTEN_OVERRIDE;

+ virtual bool isWaitingForLocalProxyActivate() const SWIFTEN_OVERRIDE;

+ virtual bool isTryingCandidates() const SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createLocalCandidateSession() SWIFTEN_OVERRIDE;

+ virtual boost::shared_ptr<TransportSession> createRemoteCandidateSession() SWIFTEN_OVERRIDE;

+

+ void handleWaitForRemoteTerminationTimeout();

+

+ void stopAll();

+ void setInternalState(State state);

+ void setFinishedState(FileTransfer::State::Type, const boost::optional<FileTransferError>& error);

+

+ static FileTransfer::State::Type getExternalState(State state);

+

+ private:

+ IDGenerator* idGenerator;

+ boost::shared_ptr<ReadBytestream> stream;

+ JingleFileTransferFileInfo fileInfo;

+ FileTransferOptions options;

+ JingleContentID contentID;

+ IncrementalBytestreamHashCalculator* hashCalculator;

+ State state;

+ bool candidateAcknowledged;

+

+ Timer::ref waitForRemoteTermination;

+

+ boost::bsignals::connection processedBytesConnection;

+ boost::bsignals::connection transferFinishedConnection;

+ };

+ class SWIFTEN_API ReadBytestream {

+ public:

+ virtual ~ReadBytestream();

+

+ /**

+ * Return an empty vector if no more data is available.

+ * Use onDataAvailable signal for signaling there is data available again.

+ */

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

+

+ virtual bool isFinished() const = 0;

+

+ public:

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

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

+ };

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ const FileTransferOptions& options) :

+ connectionFactory(connectionFactory),

+ timerFactory(timerFactory),

+ options(options) {

+ const std::vector<JingleS5BTransportPayload::Candidate>& candidates) {

+ foreach(JingleS5BTransportPayload::Candidate c, candidates) {

+ this->candidates.push(c);

+ }

+ tryNextCandidate();

+ if (s5bSession) {

+ sessionReadyConnection.disconnect();

+ s5bSession->stop();

+ }

+ if (candidates.empty()) {

+ SWIFT_LOG(debug) << "No more candidates" << std::endl;

+ onCandidateSelectFinished(

+ boost::optional<JingleS5BTransportPayload::Candidate>(), boost::shared_ptr<SOCKS5BytestreamClientSession>());

+ }

+ else {

+ lastCandidate = candidates.top();

+ candidates.pop();

+ SWIFT_LOG(debug) << "Trying candidate " << lastCandidate.cid << std::endl;

+ if ((lastCandidate.type == JingleS5BTransportPayload::Candidate::DirectType && options.isDirectAllowed()) ||

+ (lastCandidate.type == JingleS5BTransportPayload::Candidate::AssistedType && options.isAssistedAllowed()) ||

+ (lastCandidate.type == JingleS5BTransportPayload::Candidate::ProxyType && options.isProxiedAllowed())) {

+ boost::shared_ptr<Connection> connection = connectionFactory->createConnection();

+ s5bSession = boost::make_shared<SOCKS5BytestreamClientSession>(

+ connection, lastCandidate.hostPort, socks5DstAddr, timerFactory);

+ sessionReadyConnection = s5bSession->onSessionReady.connect(

+ boost::bind(&RemoteJingleTransportCandidateSelector::handleSessionReady, this, _1));

+ s5bSession->start();

+ }

+ else {

+ SWIFT_LOG(debug) << "Can't handle this type of candidate" << std::endl;

+ tryNextCandidate();

+ }

+ }

+ sessionReadyConnection.disconnect();

+ if (error) {

+ s5bSession.reset();

+ tryNextCandidate();

+ }

+ else {

+ onCandidateSelectFinished(lastCandidate, s5bSession);

+ }

+ this->socks5DstAddr = socks5DstAddr;

+ class ConnectionFactory;

+ class TimerFactory;

+

+ class RemoteJingleTransportCandidateSelector {

+ public:

+ RemoteJingleTransportCandidateSelector(ConnectionFactory*, TimerFactory*, const FileTransferOptions&);

+ virtual ~RemoteJingleTransportCandidateSelector();

+

+ virtual void addCandidates(const std::vector<JingleS5BTransportPayload::Candidate>&);

+ virtual void setSOCKS5DstAddr(const std::string&);

+ virtual void startSelectingCandidate();

+ virtual void stopSelectingCandidate();

+

+ boost::signal<void (const boost::optional<JingleS5BTransportPayload::Candidate>&, boost::shared_ptr<SOCKS5BytestreamClientSession>)> onCandidateSelectFinished;

+

+ private:

+ void tryNextCandidate();

+ void handleSessionReady(bool error);

+

+ private:

+ ConnectionFactory* connectionFactory;

+ TimerFactory* timerFactory;

+

+ std::priority_queue<

+ JingleS5BTransportPayload::Candidate,

+ std::vector<JingleS5BTransportPayload::Candidate>,

+ JingleS5BTransportPayload::CompareCandidate> candidates;

+ boost::shared_ptr<SOCKS5BytestreamClientSession> s5bSession;

+ boost::bsignals::connection sessionReadyConnection;

+ JingleS5BTransportPayload::Candidate lastCandidate;

+ std::string socks5DstAddr;

+ FileTransferOptions options;

+ };

+ public:

+ S5BTransportSession(

+ boost::shared_ptr<T> session,

+ boost::shared_ptr<ReadBytestream> readStream) :

+ session(session),

+ readStream(readStream) {

+ initialize();

+ }

+ S5BTransportSession(

+ boost::shared_ptr<T> session,

+ boost::shared_ptr<WriteBytestream> writeStream) :

+ session(session),

+ writeStream(writeStream) {

+ initialize();

+ }

+ virtual ~S5BTransportSession() {

+ }

+ virtual void start() SWIFTEN_OVERRIDE {

+ if (readStream) {

+ session->startSending(readStream);

+ }

+ else {

+ session->startReceiving(writeStream);

+ }

+ }

+ virtual void stop() SWIFTEN_OVERRIDE {

+ session->stop();

+ }

+ private:

+ void initialize() {

+ finishedConnection = session->onFinished.connect(boost::bind(boost::ref(onFinished), _1));

+ bytesSentConnection = session->onBytesSent.connect(boost::bind(boost::ref(onBytesSent), _1));

+ }

+ private:

+ boost::shared_ptr<T> session;

+ boost::shared_ptr<ReadBytestream> readStream;

+ boost::shared_ptr<WriteBytestream> writeStream;

+ boost::bsignals::scoped_connection finishedConnection;

+ boost::bsignals::scoped_connection bytesSentConnection;

+ boost::shared_ptr<Connection> connection,

+ const HostAddressPort& addressPort,

+ const std::string& destination,

+ TimerFactory* timerFactory) :

+ connection(connection),

+ addressPort(addressPort),

+ destination(destination),

+ state(Initial),

+ chunkSize(131072) {

+ weFailedTimeout = timerFactory->createTimer(3000);

+ weFailedTimeout->onTick.connect(

+ boost::bind(&SOCKS5BytestreamClientSession::handleWeFailedTimeout, this));

+ weFailedTimeout->onTick.disconnect(

+ boost::bind(&SOCKS5BytestreamClientSession::handleWeFailedTimeout, this));

+ weFailedTimeout->stop();

+ assert(state == Initial);

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

+ weFailedTimeout->start();

+ connectFinishedConnection = connection->onConnectFinished.connect(

+ boost::bind(&SOCKS5BytestreamClientSession::handleConnectFinished, this, _1));

+ connection->connect(addressPort);

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

+ if (state < Ready) {

+ weFailedTimeout->stop();

+ }

+ if (state == Finished) {

+ return;

+ }

+ closeConnection();

+ readBytestream.reset();

+ state = Finished;

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

+ ByteArray bndAddress;

+ switch(state) {

+ case Initial:

+ hello();

+ break;

+ case Hello:

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

+ unsigned char version = unprocessedData[0];

+ unsigned char authMethod = unprocessedData[1];

+ if (version != 5 || authMethod != 0) {

+ // signal failure to upper level

+ finish(true);

+ return;

+ }

+ unprocessedData.clear();

+ authenticate();

+ }

+ break;

+ case Authenticating:

+ if (unprocessedData.size() < 5) {

+ // need more data to start progressing

+ break;

+ }

+ if (unprocessedData[0] != '\x05') {

+ // wrong version

+ // disconnect & signal failure

+ finish(true);

+ break;

+ }

+ if (unprocessedData[1] != '\x00') {

+ // no success

+ // disconnect & signal failure

+ finish(true);

+ break;

+ }

+ if (unprocessedData[3] != '\x03') {

+ // we expect x'03' = DOMAINNAME here

+ // disconnect & signal failure

+ finish(true);

+ break;

+ }

+ if (static_cast<size_t>(unprocessedData[4]) + 1 > unprocessedData.size() + 5) {

+ // complete domainname and port not available yet

+ break;

+ }

+ bndAddress = createByteArray(&vecptr(unprocessedData)[5], unprocessedData[4]);

+ if (unprocessedData[unprocessedData[4] + 5] != 0 && bndAddress == createByteArray(destination)) {

+ // we expect a 0 as port

+ // disconnect and fail

+ finish(true);

+ }

+ unprocessedData.clear();

+ state = Ready;

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

+ // issue ready signal so the bytestream can be used for reading or writing

+ weFailedTimeout->stop();

+ onSessionReady(false);

+ break;

+ case Ready:

+ SWIFT_LOG(debug) << "Received further data in Ready state." << std::endl;

+ break;

+ case Reading:

+ case Writing:

+ case Finished:

+ SWIFT_LOG(debug) << "Unexpected receive of data. Current state: " << state << std::endl;

+ SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData) << std::endl;

+ unprocessedData.clear();

+ //assert(false);

+ }

+ // Version 5, 1 auth method, No authentication

+ const SafeByteArray hello = createSafeByteArray("\x05\x01\x00", 3);

+ connection->write(hello);

+ state = Hello;

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

+ SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4);

+ SafeByteArray message = header;

+ append(message, createSafeByteArray(boost::numeric_cast<char>(destination.size())));

+ authenticateAddress = createByteArray(destination);

+ append(message, authenticateAddress);

+ append(message, createSafeByteArray("\x00\x00", 2)); // 2 byte for port

+ connection->write(message);

+ state = Authenticating;

+ if (state == Ready) {

+ state = Reading;

+ writeBytestream = writeStream;

+ writeBytestream->write(unprocessedData);

+ unprocessedData.clear();

+ } else {

+ SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

+ }

+ if (state == Ready) {

+ state = Writing;

+ readBytestream = readStream;

+ dataWrittenConnection = connection->onDataWritten.connect(

+ boost::bind(&SOCKS5BytestreamClientSession::sendData, this));

+ sendData();

+ } else {

+ SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;

+ }

+ return addressPort;

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

+ try {

+ boost::shared_ptr<ByteArray> dataToSend = readBytestream->read(boost::numeric_cast<size_t>(chunkSize));

+ connection->write(createSafeByteArray(*dataToSend));

+ onBytesSent(dataToSend->size());

+ }

+ catch (const BytestreamException&) {

+ finish(true);

+ }

+ }

+ else {

+ finish(false);

+ }

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

+ if (state < Ready) {

+ weFailedTimeout->stop();

+ }

+ closeConnection();

+ readBytestream.reset();

+ if (state == Initial || state == Hello || state == Authenticating) {

+ onSessionReady(true);

+ }

+ else {

+ state = Finished;

+ if (error) {

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

+ } else {

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

+ }

+ }

+ connectFinishedConnection.disconnect();

+ if (error) {