/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <Swiften/Base/API.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/FileTransfer/FileTransferTransporter.h>

#include <Swiften/FileTransfer/FileTransferTransporterFactory.h>

#include <Swiften/FileTransfer/IBBReceiveSession.h>

#include <Swiften/FileTransfer/IBBReceiveTransportSession.h>

#include <Swiften/FileTransfer/IBBSendSession.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamServerManager.h>

#include <Swiften/FileTransfer/TransportSession.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class DummyFileTransferTransporter : public FileTransferTransporter {

public:

enum Role {

Initiator,

Responder

};

public:

DummyFileTransferTransporter(

const JID& initiator,

const JID& responder,

Role role,

SOCKS5BytestreamRegistry* s5bRegistry,

SOCKS5BytestreamServerManager* /* s5bServerManager */,

SOCKS5BytestreamProxiesManager* /* s5bProxy */,

IDGenerator* /* idGenerator */,

ConnectionFactory*,

TimerFactory*,

CryptoProvider* cryptoProvider,

IQRouter* iqRouter,

}

void initialize() {

s5bSessionID_ = s5bRegistry_->generateSessionID();

}

virtual void startGeneratingLocalCandidates() {

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

onLocalCandidatesGenerated(s5bSessionID_, candidates, getSOCKS5DstAddr());

}

virtual void stopGeneratingLocalCandidates() {

}

virtual void addRemoteCandidates(const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string&) {

}

virtual void startTryingRemoteCandidates() {

onRemoteCandidateSelectFinished(s5bSessionID_, boost::optional<JingleS5BTransportPayload::Candidate>());

}

virtual void stopTryingRemoteCandidates() {

}

virtual void startActivatingProxy(const JID& /* proxy */) {

}

virtual void stopActivatingProxy() {

}

virtual boost::shared_ptr<TransportSession> createIBBSendSession(const std::string& sessionID, unsigned int blockSize, boost::shared_ptr<ReadBytestream> stream) {

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

sessionID, initiator_, responder_, stream, iqRouter_);

ibbSession->setBlockSize(blockSize);

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

}

virtual boost::shared_ptr<TransportSession> createIBBReceiveSession(const std::string& sessionID, unsigned long long size, boost::shared_ptr<WriteBytestream> stream) {

private:

std::string getSOCKS5DstAddr() const {

std::string result;

if (role_ == Initiator) {

result = getInitiatorCandidateSOCKS5DstAddr();

}

else {

result = getResponderCandidateSOCKS5DstAddr();

}

return result;

}

std::string getInitiatorCandidateSOCKS5DstAddr() const {

return Hexify::hexify(crypto_->getSHA1Hash(createSafeByteArray(s5bSessionID_ + initiator_.toString() + responder_.toString())));

}

std::string getResponderCandidateSOCKS5DstAddr() const {

return Hexify::hexify(crypto_->getSHA1Hash(createSafeByteArray(s5bSessionID_ + responder_.toString() + initiator_.toString())));

}

private:

JID initiator_;

JID responder_;

Role role_;

SOCKS5BytestreamRegistry* s5bRegistry_;

CryptoProvider* crypto_;

std::string s5bSessionID_;

IQRouter* iqRouter_;

};

class DummyFileTransferTransporterFactory : public FileTransferTransporterFactory {

public:

DummyFileTransferTransporterFactory(

SOCKS5BytestreamRegistry* s5bRegistry,

SOCKS5BytestreamServerManager* s5bServerManager,

SOCKS5BytestreamProxiesManager* s5bProxy,

IDGenerator* idGenerator,

ConnectionFactory* connectionFactory,

TimerFactory* timerFactory,

CryptoProvider* cryptoProvider,

IQRouter* iqRouter) : s5bRegistry_(s5bRegistry), s5bServerManager_(s5bServerManager), s5bProxy_(s5bProxy), idGenerator_(idGenerator), connectionFactory_(connectionFactory), timerFactory_(timerFactory), cryptoProvider_(cryptoProvider), iqRouter_(iqRouter) {

}

virtual ~DummyFileTransferTransporterFactory() {

}

virtual FileTransferTransporter* createInitiatorTransporter(const JID& initiator, const JID& responder, const FileTransferOptions& options) {

DummyFileTransferTransporter* transporter = new DummyFileTransferTransporter(

initiator,

responder,

DummyFileTransferTransporter::Initiator,

s5bRegistry_,

s5bServerManager_,

s5bProxy_,

idGenerator_,

connectionFactory_,

timerFactory_,

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <iostream>

#include <boost/bind.hpp>

#include <boost/optional.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Override.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Elements/IBB.h>

#include <Swiften/Elements/JingleFileTransferDescription.h>

#include <Swiften/Elements/JingleIBBTransportPayload.h>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/FileTransfer/ByteArrayReadBytestream.h>

#include <Swiften/FileTransfer/DefaultFileTransferTransporterFactory.h>

#include <Swiften/FileTransfer/OutgoingJingleFileTransfer.h>

#include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

class OutgoingJingleFileTransferTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(OutgoingJingleFileTransferTest);

CPPUNIT_TEST(test_SendSessionInitiateOnStart);

CPPUNIT_TEST(test_FallbackToIBBAfterFailingS5B);

CPPUNIT_TEST(test_ReceiveSessionTerminateAfterSessionInitiate);

CPPUNIT_TEST(test_DeclineEmitsFinishedStateCanceled);

CPPUNIT_TEST_SUITE_END();

class FTStatusHelper {

public:

FTStatusHelper() : finishedCalled(false), error(FileTransferError::UnknownError) {

}

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

finishedCalled = true;

if (error.is_initialized()) this->error = error.get().getType();

}

void handleFileTransferStatusChanged(FileTransfer::State fileTransferSTate) {

state = fileTransferSTate;

}

public:

bool finishedCalled;

FileTransferError::Type error;

boost::optional<FileTransfer::State> state;

};

public:

JID to("test@foo.com/bla");

JingleFileTransferFileInfo fileInfo;

fileInfo.setDescription("some file");

fileInfo.setName("test.bin");

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

fileInfo.setSize(1024 * 1024);

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

to,

boost::shared_ptr<JingleSession>(fakeJingleSession),

stream,

ftTransportFactory,

timerFactory,

idGen,

fileInfo,

crypto.get()));

}

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

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

request->setFrom(from);

return request;

}

void setUp() {

crypto = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

fakeJingleSession = new FakeJingleSession("foo@bar.com/baz", "mysession");

jingleContentPayload = boost::make_shared<JingleContentPayload>();

stanzaChannel = new DummyStanzaChannel();

iqRouter = new IQRouter(stanzaChannel);

eventLoop = new DummyEventLoop();

timerFactory = new DummyTimerFactory();

connectionFactory = new DummyConnectionFactory(eventLoop);

serverConnectionFactory = new DummyConnectionServerFactory(eventLoop);

s5bRegistry = new SOCKS5BytestreamRegistry();

networkEnvironment = new PlatformNetworkEnvironment();

natTraverser = new PlatformNATTraversalWorker(eventLoop);

bytestreamServerManager = new SOCKS5BytestreamServerManager(s5bRegistry, serverConnectionFactory, networkEnvironment, natTraverser);

data.clear();

for (int n=0; n < 1024 * 1024; ++n) {

data.push_back(34);

}

stream = boost::make_shared<ByteArrayReadBytestream>(data);

s5bProxy = new SOCKS5BytestreamProxiesManager(connectionFactory, timerFactory, resolver, iqRouter, "bar.com");

ftTransportFactory = new DummyFileTransferTransporterFactory(s5bRegistry, bytestreamServerManager, s5bProxy, idGen, connectionFactory, timerFactory, crypto.get(), iqRouter);

}

void tearDown() {

delete ftTransportFactory;

delete s5bProxy;

delete idGen;

delete bytestreamServerManager;

delete natTraverser;

delete networkEnvironment;

delete s5bRegistry;

delete serverConnectionFactory;

delete connectionFactory;

delete timerFactory;

delete eventLoop;

delete iqRouter;

delete stanzaChannel;

}

void test_SendSessionInitiateOnStart() {

boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

transfer->start();

FakeJingleSession::InitiateCall call = getCall<FakeJingleSession::InitiateCall>(0);

JingleFileTransferDescription::ref description = boost::dynamic_pointer_cast<JingleFileTransferDescription>(call.description);

CPPUNIT_ASSERT(description);

CPPUNIT_ASSERT(static_cast<size_t>(1048576) == description->getFileInfo().getSize());

CPPUNIT_ASSERT(transport);

}

void test_FallbackToIBBAfterFailingS5B() {

transfer->start();

FakeJingleSession::InitiateCall call = getCall<FakeJingleSession::InitiateCall>(0);

fakeJingleSession->handleSessionAcceptReceived(call.id, call.description, call.payload);

// send candidate failure

JingleS5BTransportPayload::ref candidateFailurePayload = boost::make_shared<JingleS5BTransportPayload>();

candidateFailurePayload->setCandidateError(true);

candidateFailurePayload->setSessionID(call.payload->getSessionID());

fakeJingleSession->handleTransportInfoReceived(call.id, candidateFailurePayload);

// no S5B candidates -> fallback to IBB

// call at position 1 is the candidate our candidate error

FakeJingleSession::ReplaceTransportCall replaceCall = getCall<FakeJingleSession::ReplaceTransportCall>(2);

// accept transport replace

fakeJingleSession->handleTransportAcceptReceived(replaceCall.id, replaceCall.payload);

IQ::ref iqOpenStanza = stanzaChannel->getStanzaAtIndex<IQ>(0);

CPPUNIT_ASSERT(iqOpenStanza);

IBB::ref ibbOpen = iqOpenStanza->getPayload<IBB>();

CPPUNIT_ASSERT(ibbOpen);

CPPUNIT_ASSERT_EQUAL(IBB::Open, ibbOpen->getAction());

}

void test_ReceiveSessionTerminateAfterSessionInitiate() {

boost::shared_ptr<OutgoingJingleFileTransfer> transfer = createTestling();

transfer->start();

getCall<FakeJingleSession::InitiateCall>(0);

FTStatusHelper helper;

helper.finishedCalled = false;