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

assert(!ownFullJID.isBare());

connectivityManager = new ConnectivityManager(natTraverser);

bytestreamRegistry = new SOCKS5BytestreamRegistry();

bytestreamProxy = new SOCKS5BytestreamProxy(connectionFactory, timerFactory);

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

remoteCandidateSelectorFactory = new DefaultRemoteJingleTransportCandidateSelectorFactory(connectionFactory, timerFactory);

incomingFTManager->onIncomingFileTransfer.connect(onIncomingFileTransfer);

}

FileTransferManagerImpl::~FileTransferManagerImpl() {

if (bytestreamServer) {

bytestreamServer->stop();

}

delete incomingFTManager;

delete outgoingFTManager;

if(receipient.isBare()) {

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

if (fullJID.is_initialized()) {

receipient = fullJID.get();

} else {

return OutgoingFileTransfer::ref();

}

}

}

}

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/Jingle/Jingle.h>

#include <Swiften/FileTransfer/IncomingJingleFileTransfer.h>

namespace Swift {

RemoteJingleTransportCandidateSelectorFactory* remoteFactory,

jingleSessionManager->addIncomingSessionHandler(this);

}

IncomingFileTransferManager::~IncomingFileTransferManager() {

jingleSessionManager->removeIncomingSessionHandler(this);

}

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

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

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

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

onIncomingFileTransfer(transfer);

} else {

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

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

}

}

else {

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

}

class JingleSessionManager;

class RemoteJingleTransportCandidateSelectorFactory;

class LocalJingleTransportCandidateGeneratorFactory;

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamProxy;

class TimerFactory;

class IncomingFileTransferManager : public IncomingJingleSessionHandler {

public:

~IncomingFileTransferManager();

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

private:

private:

JingleSessionManager* jingleSessionManager;

IQRouter* router;

RemoteJingleTransportCandidateSelectorFactory* remoteFactory;

LocalJingleTransportCandidateGeneratorFactory* localFactory;

SOCKS5BytestreamRegistry* bytestreamRegistry;

SOCKS5BytestreamProxy* bytestreamProxy;

TimerFactory* timerFactory;

};

}

#include <Swiften/JID/JID.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/Jingle/JingleSessionImpl.h>

#include <Swiften/Jingle/JingleContentID.h>

#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

#include <Swiften/Base/IDGenerator.h>

namespace Swift {

idGenerator = new IDGenerator();

}

OutgoingFileTransferManager::~OutgoingFileTransferManager() {

delete idGenerator;

}

// check if receipient support Jingle FT

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

assert(jingleSession);

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

// otherwise try SI

// else fail

return jingleFT;

}

class JID;

class IDGenerator;

class ReadBytestream;

class StreamInitiationFileInfo;

class SOCKS5BytestreamRegistry;

class SOCKS5BytestreamProxy;

class OutgoingFileTransferManager {

public:

~OutgoingFileTransferManager();

private:

JingleSessionManager* jsManager;

IQRouter* iqRouter;

EntityCapsProvider* capsProvider;

RemoteJingleTransportCandidateSelectorFactory* remoteFactory;

LocalJingleTransportCandidateGeneratorFactory* localFactory;

IDGenerator *idGenerator;

SOCKS5BytestreamRegistry* bytestreamRegistry;

SOCKS5BytestreamProxy* bytestreamProxy;

};

#pragma once

#include <Swiften/Jingle/JingleSession.h>

namespace Swift {

class IncomingJingleSessionHandler {

public:

virtual ~IncomingJingleSessionHandler();

};

}

namespace Swift {

JingleResponder::JingleResponder(JingleSessionManager* sessionManager, IQRouter* router) : SetResponder<JinglePayload>(router), sessionManager(sessionManager), router(router) {

}

JingleResponder::~JingleResponder() {

}

if (payload->getAction() == JinglePayload::SessionInitiate) {

if (sessionManager->getSession(from, payload->getSessionID())) {

// TODO: Add tie-break error

sendError(from, id, ErrorPayload::Conflict, ErrorPayload::Cancel);

}

else {

sendResponse(from, id, boost::shared_ptr<JinglePayload>());

if (!payload->getInitiator().isBare()) {

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

} else {

SWIFT_LOG(debug) << "Unable to create Jingle session due to initiator not being a full JID." << std::endl;

}

}

}

else {

JingleSessionImpl::ref session;

if (payload->getInitiator().isValid()) {

SWIFT_LOG(debug) << "Lookup session by initiator." << std::endl;

void JingleSessionManager::removeIncomingSessionHandler(IncomingJingleSessionHandler* handler) {

erase(incomingSessionHandlers, handler);

}

void JingleSessionManager::registerOutgoingSession(const JID& initiator, JingleSessionImpl::ref session) {

sessions.insert(std::make_pair(JIDSession(initiator, session->getID()), session));

SWIFT_LOG(debug) << "Added session " << session->getID() << " for initiator " << initiator.toString() << std::endl;

}

sessions.insert(std::make_pair(JIDSession(initiator, session->getID()), session));

foreach (IncomingJingleSessionHandler* handler, incomingSessionHandlers) {

return;

}

}

// TODO: Finish session

}

}

~JingleSessionManager();

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

void addIncomingSessionHandler(IncomingJingleSessionHandler* handler);

void removeIncomingSessionHandler(IncomingJingleSessionHandler* handler);

void registerOutgoingSession(const JID& initiator, JingleSessionImpl::ref);

protected:

private:

IQRouter* router;

JingleResponder* responder;

std::vector<IncomingJingleSessionHandler*> incomingSessionHandlers;

struct JIDSession {

JIDSession(const JID& initiator, const std::string& session) : initiator(initiator), session(session) {}

bool operator<(const JIDSession& o) const {

return initiator == o.initiator ? session < o.session : initiator < o.initiator;