Version 2.1, February 1999

Copyright (C) 1991, 1999 Free Software Foundation, Inc.

Everyone is permitted to copy and distribute verbatim copies

of this license document, but changing it is not allowed.

* CPPUNIT_SOURCELINE() )

* \endcode

*/

struct Asserter

{

/*! \brief Throws a Exception with the specified message and location.

*/

const SourceLine &sourceLine = SourceLine() );

/*! \brief Throws a Exception with the specified message and location.

* \deprecated Use fail( Message, SourceLine ) instead.

*/

const SourceLine &sourceLine = SourceLine() );

/*! \brief Throws a Exception with the specified message and location.

std::string message,

const SourceLine &sourceLine = SourceLine() );

* Typically used to create 'not equal' message, or to check that a message

* contains the expected content when writing unit tests for your custom

* assertions.

*

* \param expectedValue String that represents the expected value.

* \return \a expectedValue prefixed with "Expected: ".

* \see makeActual().

*/

static std::string CPPUNIT_API makeExpected( const std::string &expectedValue );

/*! \brief Returns an actual value string for a message.

* Typically used to create 'not equal' message, or to check that a message

*/

static std::string CPPUNIT_API makeActual( const std::string &actualValue );

static Message CPPUNIT_API makeNotEqualMessage( const std::string &expectedValue,

const std::string &actualValue,

const AdditionalMessage &additionalMessage = AdditionalMessage(),

const std::string &shortDescription = "equality assertion failed");

/*! \brief Throws an Exception with the specified message and location.

* \param expected Text describing the expected value.

* \param actual Text describing the actual value.

* what are the differences between the expected and actual value.

* \param shortDescription Short description for the failure message.

*/

std::string actual,

const SourceLine &sourceLine,

const AdditionalMessage &additionalMessage = AdditionalMessage(),

std::string shortDescription = "equality assertion failed" );

/*! \brief Throws an Exception with the specified message and location.

* \param shouldFail if \c true then the exception is thrown. Otherwise

* nothing happen.

* \param expected Text describing the expected value.

#pragma warning( disable: 4251 ) // X needs to have dll-interface to be used by clients of class Z

#endif

#include <string>

CPPUNIT_NS_BEGIN

/*! \brief Message associated to an Exception.

* \ingroup CreatingNewAssertions

* A message is composed of two items:

class CPPUNIT_API Message

{

public:

// Ensure thread-safe copy by detaching the string.

Message( const Message &other );

const std::string &detail2,

const std::string &detail3 );

Message &operator =( const Message &other );

/*! \brief Returns the short description.

private:

std::string m_shortDescription;

Details m_details;

};

// Version number of package

#ifndef CPPUNIT_VERSION

#endif

#include <cppunit/config/CppUnitApi.h> // define CPPUNIT_API & CPPUNIT_NEED_DLL_DECL

# endif // !defined(CPPUNIT_NO_STD_NAMESPACE)

#endif // !defined(CPPUNIT_HAVE_NAMESPACES)

// Compiler error location format for CompilerOutputter

// If not define, assumes that it's gcc

// See class CompilerOutputter for format.

/// \internal

#define _CPPUNIT_DO_JOIN2( symbol1, symbol2 ) symbol1##symbol2

/*! Adds the line number to the specified string to create a unique identifier.

* \param prefix Prefix added to the line number to create a unique identifier.

* \see CPPUNIT_TEST_SUITE_REGISTRATION for an example of usage.

*/

/*! Defines wrap colunm for %CppUnit. Used by CompilerOuputter.

*/

~ProtectorGuard();

private:

TestResult *m_result;

};

public:

ExclusiveZone( SynchronizationObject *syncObject )

{

}

~ExclusiveZone()

{

}

};

virtual void setSynchronizationObject( SynchronizationObject *syncObject );

#include <cppunit/Exception.h>

#include <cppunit/Asserter.h>

#include <cppunit/portability/Stream.h>

#include <stdio.h>

#include <float.h> // For struct assertion_traits<double>

*

* Here is an example of specialising these traits:

*

* {

* return x == y;

* }

* static std::string toString( const std::string& x )

* {

* std::string text = '"' + x + '"'; // adds quote around the string to see whitespace

return x == y;

}

static std::string toString( const T& x )

{

}

};

/*! \brief Traits used by CPPUNIT_ASSERT_DOUBLES_EQUAL().

*

* This specialisation from @c struct @c assertion_traits<> ensures that

return x == y;

}

static std::string toString( double x )

{

#ifdef DBL_DIG

const std::string &message );

/* A set of macros which allow us to get the line number

* and file name at the point of an error.

* Just goes to show that preprocessors do have some

(message) ) )

#endif

/*! \brief Macro for primitive double value comparisons.

* \ingroup Assertions

*

// implementation detail

#define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \

CPPUNIT_NS::TypeInfoHelper::getClassName( typeid(exception) )

#else

#include <cppunit/Exception.h>

#include <cppunit/TestCase.h>

# include <cppunit/extensions/TypeInfoHelper.h>

#endif

{

static void expectedException()

{

throw Exception( Message(

"expected exception not thrown",

"Expected exception type: " +

TestCase( name ),

m_ownFixture( true ),

m_fixture( new Fixture() ),

{

}

TestCase( name ),

m_ownFixture( false ),

m_fixture( &fixture ),

{

}

TestCase( name ),

m_ownFixture( true ),

m_fixture( fixture ),

{

}

~TestCaller()

{

void runTest()

{

}

void setUp()

private:

bool m_ownFixture;

Fixture *m_fixture;

};

#pragma warning( disable: 4251 ) // X needs to have dll-interface to be used by clients of class Z

#endif

#include <string>

CPPUNIT_NS_BEGIN

class Test;

/*! \brief A List of Test representing a path to access a Test.

* \ingroup ExecutingTest

*

void checkIndexValid( int index ) const;

/// A list of test names.

/*! \brief Splits a path string into its test name components.

* \param pathAsString Path string created with toString().

PathTestNames &testNames );

protected:

Tests m_tests;

};

#endif

#include <cppunit/SynchronizedObject.h>

#include <string>

CPPUNIT_NS_BEGIN

class TestListener;

/*! \brief Manages TestListener.

* \ingroup TrackingTestExecution

*

virtual void endTestRun( Test *test );

protected:

TestListeners m_listeners;

ProtectorChain *m_protectorChain;

bool m_stop;

#endif

#include <cppunit/TestSuccessListener.h>

CPPUNIT_NS_BEGIN

/*! \brief Collects test result.

* \ingroup WritingTestResult

class CPPUNIT_API TestResultCollector : public TestSuccessListener

{

public:

/*! Constructs a TestResultCollector object.

#endif

#include <cppunit/TestComposite.h>

CPPUNIT_NS_BEGIN

* TestComposite interface instead.

* \return Reference on a vector that contains the tests of the suite.

*/

/*! Destroys all the tests of the suite.

*/

Test *doGetChildTestAt( int index ) const;

private:

};

virtual void addFailure( const TestFailure &failure );

virtual void startTest( Test *test );

virtual void print( OStream &stream );

};

/** insertion operator for easy output */

#endif

#include <cppunit/Outputter.h>

#include <cppunit/portability/Stream.h>

*/

XmlOutputter( TestResultCollector *result,

OStream &stream,

/// Destructor.

virtual ~XmlOutputter();

*/

virtual void setStandalone( bool standalone );

/*! \brief Sets the root element and adds its children.

*

virtual void fillFailedTestsMap( FailedTests &failedTests );

protected:

TestResultCollector *m_result;

OStream &m_stream;

* CPPUNIT_HAVE_WIN32_DLL_LOADER

* If defined, Win32 implementation of DynamicLibraryManager will be used.

*

* CPPUNIT_HAVE_UNIX_DLL_LOADER

* If defined, Unix implementation (dlfcn.h) of DynamicLibraryManager will be used.

*/

#undef CPPUNIT_PLUGIN_EXPORT

#define CPPUNIT_PLUGIN_EXPORT extern "C" __declspec(dllexport)

// Is Unix platform and have shl_load() (hp-ux)

#elif defined(CPPUNIT_HAVE_SHL_LOAD)

#define CPPUNIT_HAVE_UNIX_SHL_LOADER 1

#define CPPUNIT_HAVE_NAMESPACES 1

#endif

#define CPPUNIT_HAVE_SSTREAM 1

/* Name of package */

// Uncomment to turn on STL wrapping => use this to test compilation.

// This will make CppUnit subclass std::vector & co to provide default

// parameter.

*/

/* _INCLUDE_CPPUNIT_CONFIG_MSVC6_H */

#endif

// Moved outside the try{} statement to handle the case where the

// expected exception type is Exception (expecting assertion failure).

throw Exception( Message(

"expected exception not thrown",

"Expected exception type: " +

*

* Should be overriden to check the exception.

*/

{

}

};

#define CPPUNIT_TEST_SUITE_END() \

} \

\

static CPPUNIT_NS::TestSuite *suite() \

{ \

const CPPUNIT_NS::TestNamer &namer = getTestNamer__(); \

CPPUNIT_NS::ConcretTestFixtureFactory<TestFixtureType> factory; \

namer, \

factory ); \

TestFixtureType::addTestsToSuite( context ); \

} \

private: /* dummy typedef so that the macro can still end with ';'*/ \

typedef int CppUnitDummyTypedefForSemiColonEnding__

&TestFixtureType::testMethod, \

context.makeFixture() ) ) )

/*! \brief Add a test which fail if the specified exception is not caught.

*

* Example:

* #include <vector>

* class MyTest : public CppUnit::TestFixture {

* CPPUNIT_TEST_SUITE( MyTest );

* CPPUNIT_TEST_SUITE_END();

* public:

* void testVectorAtThrow()

* {

* std::vector<int> v;

* }

* };

* \endcode

* of a test class without subclassing the test. Instead, one can

* subclass the decorater and use it to wrap the test class.

*

*/

class CPPUNIT_API TestCaseDecorator : public TestCase

{

protected:

TestCase *m_test;

};

#pragma warning( disable: 4251) // X needs to have dll-interface to be used by clients of class Z

#endif

#include <cppunit/extensions/TestFactory.h>

#include <string>

class TestSuite;

/*! \brief Registry for TestFactory.

* \ingroup CreatingTestSuite

*

void operator =( const TestFactoryRegistry &copy );

private:

Factories m_factories;

std::string m_name;

#include <cppunit/Portability.h>

#include <string>

/*! \def CPPUNIT_TESTNAMER_DECL( variableName, FixtureType )

* \brief Declares a TestNamer.

*

*

* \code

* void someMethod()

* \relates TestNamer

* \see TestNamer

*/

# define CPPUNIT_TESTNAMER_DECL( variableName, FixtureType ) \

CPPUNIT_NS::TestNamer variableName( typeid(FixtureType) )

CPPUNIT_NS_BEGIN

/*! \brief Names a test or a fixture suite.

*

* TestNamer is usually instantiated using CPPUNIT_TESTNAMER_DECL.

class CPPUNIT_API TestNamer

{

public:

/*! \brief Constructs a namer using the fixture's type-info.

* \param typeInfo Type-info of the fixture type. Use to name the fixture suite.

*/

TestNamer( const std::type_info &typeInfo );

/*! \brief Constructs a namer using the specified fixture name.

* \param fixtureName Name of the fixture suite. Usually extracted using a macro.

*/

virtual std::string getTestNameFor( const std::string &testMethodName ) const;

protected:

std::string m_fixtureName;

};

CPPUNIT_NS_END

#endif // CPPUNIT_EXTENSIONS_TESTNAMER_H

#define CPPUNIT_HELPER_TESTSUITEBUILDERCONTEXT_H

#include <cppunit/Portability.h>

#include <string>

#if CPPUNIT_NEED_DLL_DECL

*/

std::string getTestNameFor( const std::string &testMethodName ) const;

/*! \brief Adds property pair.

* \param key PropertyKey string to add.

* \param value PropertyValue string to add.

// shared std::map in dll bug in VC6.

// See http://www.dinkumware.com/vc_fixes.html for detail.

typedef std::pair<std::string,std::string> Property;

TestSuite &m_suite;

const TestNamer &m_namer;

#include <cppunit/Portability.h>

#include <typeinfo>

#include <string>

CPPUNIT_NS_BEGIN

/**! \brief Helper to use type_info.

*/

class CPPUNIT_API TypeInfoHelper

static std::string getClassName( const std::type_info &info );

};

CPPUNIT_NS_END

#endif // CPPUNIT_TYPEINFOHELPER_H

#include <cppunit/Portability.h>

#include <string>

CPPUNIT_NS_BEGIN

struct StringTools

{

static std::string CPPUNIT_API toString( int value );

#pragma warning( disable: 4251 ) // X needs to have dll-interface to be used by clients of class Z

#endif

#include <string>

std::string m_name;

std::string m_content;

Attributes m_attributes;

Elements m_elements;

};

virtual void wait( bool doWait );

virtual void printResult( bool doPrintResult );

TestResultCollector *m_result;

TestResult *m_eventManager;

Outputter *m_outputter;

CPPUNIT_NS_BEGIN

void

Asserter::fail( std::string message,

const SourceLine &sourceLine )

fail( Message( "assertion failed", message ), sourceLine );

}

void

Asserter::fail( const Message &message,

const SourceLine &sourceLine )

failIf( shouldFail, Message( "assertion failed", message ), sourceLine );

}

std::string

Asserter::makeExpected( const std::string &expectedValue )

{

return "Expected: " + expectedValue;

}

std::string

Asserter::makeActual( const std::string &actualValue )

}

Message

Asserter::makeNotEqualMessage( const std::string &expectedValue,

const std::string &actualValue,

const AdditionalMessage &additionalMessage,

const std::string &shortDescription )

{

}

const AdditionalMessage &additionalMessage,

std::string shortDescription )

{

sourceLine );

}

void

Asserter::failNotEqualIf( bool shouldFail,

std::string expected,

std::string actual,

void

{

if ( !m_lastTestFailed )

stdCOut() << " : OK";

catch ( std::exception &e )

{

std::string shortDescription( "uncaught exception of type " );

shortDescription += TypeInfoHelper::getClassName( typeid(e) );

#else

shortDescription += "std::exception (or derived).";

Exception::Exception( const Exception &other )

: std::exception( other )

{

}

Exception::Exception( const Message &message,

const SourceLine &sourceLine )

: m_message( message )

, m_sourceLine( sourceLine )

{

}

#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED

Exception::Exception( std::string message,

long lineNumber,

CPPUNIT_NS_BEGIN

Message::Message( const Message &other )

{

*this = other;

}

Message::Message( const std::string &shortDescription )

: m_shortDescription( shortDescription )

{

}

Message::Message( const std::string &shortDescription,

const std::string &detail1 )

: m_shortDescription( shortDescription )

{

addDetail( detail1 );

}

const std::string &detail1,

const std::string &detail2 )

: m_shortDescription( shortDescription )

{

addDetail( detail1, detail2 );

}

const std::string &detail2,

const std::string &detail3 )

: m_shortDescription( shortDescription )

{

addDetail( detail1, detail2, detail3 );

}

Message &

Message::operator =( const Message &other )

{

Protector::reportError( const ProtectorContext &context,

const Exception &error ) const

{

actualError->setMessage( actualMessage( actualError->message(), context ) );

context.m_result->addError( context.m_test,

actualError.release() );

Protector::reportFailure( const ProtectorContext &context,

const Exception &failure ) const

{

actualFailure->setMessage( actualMessage( actualFailure->message(), context ) );

context.m_result->addFailure( context.m_test,

actualFailure.release() );

}

private:

Protector *m_protector;

const Functor &m_functor;

const ProtectorContext &m_context;

};

ProtectorChain::~ProtectorChain()

{

#define CPPUNIT_PROTECTORCHAIN_H

#include <cppunit/Protector.h>

#if CPPUNIT_NEED_DLL_DECL

#pragma warning( push )

class CPPUNIT_API ProtectorChain : public Protector

{

public:

~ProtectorChain();

void push( Protector *protector );

class ProtectFunctor;

private:

Protectors m_protectors;

};

{

}

Test *m_test;

TestResult *m_result;

std::string m_shortDescription;

SourceLine::SourceLine() :

m_lineNumber( -1 )

{

}

#include <cppunit/TestResult.h>

#include <stdexcept>

# include <typeinfo>

#endif

#include <cppunit/config/SourcePrefix.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <cppunit/TestSuite.h>

#include <assert.h>

class TestFactoryRegistryList

{

private:

Registries m_registries;

enum State {

public:

TestFactoryRegistryList()

{

stateFlag( exist );

}

TestFactoryRegistry::TestFactoryRegistry( std::string name ) :

m_name( name )

{

}

#include <cppunit/extensions/TestNamer.h>

#include <cppunit/extensions/TypeInfoHelper.h>

#include <string>

CPPUNIT_NS_BEGIN

TestNamer::TestNamer( const std::type_info &typeInfo )

{

}

TestNamer::TestNamer( const std::string &fixtureName )

: m_fixtureName( fixtureName )

{

}

TestNamer::~TestNamer()

{

}

std::string

TestNamer::getFixtureName() const

{

return m_fixtureName;

}

std::string

TestNamer::getTestNameFor( const std::string &testMethodName ) const

{

return getFixtureName() + "::" + testMethodName;

}

CPPUNIT_NS_END

TestPath::TestPath()

{

}

TestPath::TestPath( Test *root )

{

add( root );

}

TestPath::TestPath( const TestPath &other,

int indexFirst,

int count )

{

int countAdjustment = 0;

if ( indexFirst < 0 )

TestPath::TestPath( Test *searchRoot,

const std::string &pathAsString )

{

PathTestNames testNames;

#include <cppunit/TestListener.h>

#include <cppunit/TestResult.h>

#include <cppunit/tools/Algorithm.h>

#include <algorithm>

#include "DefaultProtector.h"

#include "ProtectorChain.h"

TestResult::TestResult( SynchronizationObject *syncObject )

: SynchronizedObject( syncObject )

, m_stop( false )

{

m_protectorChain->push( new DefaultProtector() );

TestResult::~TestResult()

{

delete m_protectorChain;

}

TestResultCollector::TestResultCollector( SynchronizationObject *syncObject )

: TestSuccessListener( syncObject )

{

reset();

}

/// Default constructor

TestSuite::TestSuite( std::string name )

: TestComposite( name )

{

}

}

TestSuite::getTests() const

{

return m_tests;

: m_suite( suite )

, m_namer( namer )

, m_factory( factory )

{

}

TextTestProgressListener::startTest( Test * )

{

stdCOut() << ".";

}

TextTestProgressListener::addFailure( const TestFailure &failure )

{

stdCOut() << ( failure.isError() ? "E" : "F" );

}

#include <cppunit/Portability.h>

#include <cppunit/extensions/TypeInfoHelper.h>

#include <string>

#if CPPUNIT_HAVE_GCC_ABI_DEMANGLE

#include <cxxabi.h>

#endif

CPPUNIT_NS_BEGIN

std::string

TypeInfoHelper::getClassName( const std::type_info &info )

{

int status = 0;

char* c_name = 0;

#else // CPPUNIT_HAVE_GCC_ABI_DEMANGLE

return name;

}

CPPUNIT_NS_END

CPPUNIT_NS_BEGIN

XmlDocument::XmlDocument( const std::string &encoding,

const std::string &styleSheet )

: m_styleSheet( styleSheet )

setEncoding( encoding );

}

XmlDocument::~XmlDocument()

{

delete m_rootElement;

std::string content )

: m_name( elementName )

, m_content( content )

{

}

XmlElement::XmlElement( std::string elementName,

int numericContent )

: m_name( elementName )

{

setContent( numericContent );

}

XmlOutputter::XmlOutputter( TestResultCollector *result,

OStream &stream,

: m_result( result )

, m_stream( stream )

, m_xml( new XmlDocument( encoding ) )

{

}

'PATH' : os.environ['PATH'],

'LD_LIBRARY_PATH' : os.environ.get("LD_LIBRARY_PATH", ""),

'TERM' : os.environ.get("TERM", ""),

}

if "MSVC_VERSION" in ARGUMENTS :

/*

* All rights reserved.

* See the COPYING file for more information.

*/

googleTestWasSuccessful = RUN_ALL_TESTS() == 0 ? true : false;

} catch (const ::testing::internal::GoogleTestFailureException& e) {

googleTestWasSuccessful = false;

}

auto cppUnitWasSuccessful = result.wasSuccessful() ? true : false;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void Server::handleConnectFinished(std::shared_ptr<LinkLocalConnector> connector, bool error) {

if (error) {

// TODO: Send back queued stanzas

}

else {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

std::shared_ptr<Element> DefaultElementConvertor::convertFromLua(lua_State*, int, const std::string& type) {

return std::shared_ptr<Element>();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

boost::filesystem::create_directory(result);

}

catch (const boost::filesystem::filesystem_error& e) {

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

boost::filesystem::create_directory(result);

}

catch (const boost::filesystem::filesystem_error& e) {

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

boost::filesystem::create_directories(dataPath);

}

catch (const boost::filesystem::filesystem_error& e) {

}

return dataPath;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

SWIFT_LOG(debug) << (canDoSilentUpdates ?

"The current running user has enough permissions to do a silent update." :

setAppcastFeed(appcastFeed);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

- (void)updater:(SUUpdater *)updater failedToDownloadUpdate:(SUAppcastItem *)item error:(NSError *)error {

(void)updater;

(void)item;

onNewUpdateState(AutoUpdater::State::ErrorCheckingForUpdate);

}

onNewUpdateState(AutoUpdater::State::NoUpdateAvailable);

}

else {

onNewUpdateState(AutoUpdater::State::ErrorCheckingForUpdate);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

boost::filesystem::create_directories(path);

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

void HunspellChecker::setActiveLanguage(const std::string& language) {

auto dictionaries = detectedDictionaries();

if (dictionaries.find(language) != dictionaries.end()) {

speller_ = std::unique_ptr<Hunspell>(new Hunspell(dictionaries[language].affPath.c_str(), dictionaries[language].dicPath.c_str()));

activeLangauge_ = language;

}

else {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

}

else {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

auto enableCarbonsRequest = EnableCarbonsRequest::create(client_->getIQRouter());

enableCarbonsRequestHandlerConnection_ = enableCarbonsRequest->onResponse.connect([&](Payload::ref /*payload*/, ErrorPayload::ref error) {

if (error) {

}

else {

}

enableCarbonsRequestHandlerConnection_.disconnect();

});

std::string AccountController::serializeClientOptions(const ClientOptions& options) {

std::string result;

switch (options.useTLS) {

case ClientOptions::NeverUseTLS: result += "1";break;

case ClientOptions::UseTLSWhenAvailable: result += "2";break;

case ClientOptions::RequireTLS: result += "3";break;

}

result += ",";

switch (options.proxyType) {

case ClientOptions::NoProxy: result += "1";break;

case ClientOptions::SystemConfiguredProxy: result += "2";break;

case ClientOptions::HTTPConnectProxy: result += "4";break;

}

result += ",";

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

// handle XEP-0184 Message Receipts

// incomming receipts

if (std::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

requestedReceipts_.erase(receipt->getReceivedID());

}

void ChatController::handleFileTransferCancel(std::string id) {

if (ftControllers.find(id) != ftControllers.end()) {

ftControllers[id]->cancel();

} else {

}

void ChatController::handleFileTransferStart(std::string id, std::string description) {

if (ftControllers.find(id) != ftControllers.end()) {

ftControllers[id]->start(description);

} else {

}

void ChatController::handleFileTransferAccept(std::string id, std::string filename) {

if (ftControllers.find(id) != ftControllers.end()) {

ftControllers[id]->accept(filename);

} else {

}

void ChatController::handleSendFileRequest(std::string filename) {

eventStream_->send(std::make_shared<SendFileUIEvent>(getToJID(), filename));

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));

ftOverview_->onNewFileTransferController.disconnect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

delete joinMUCWindow_;

for (JIDChatControllerPair controllerPair : chatControllers_) {

delete controllerPair.second;

}

boost::archive::text_iarchive ia(deserializeStream);

ia >> recentChats;

} catch (const boost::archive::archive_exception& e) {

return;

}

recentChats.erase(std::remove(recentChats.begin(), recentChats.end(), ChatListWindow::Chat()), recentChats.end());

JID oldMUCChatJID = mucController->getToJID().withResource(oldNickname);

JID newMUCChatJID = mucController->getToJID().withResource(newNickname);

// get current chat controller

ChatController *chatController = getChatControllerIfExists(oldMUCChatJID);

controller->handleIncomingOwnMessage(forwardedMessage);

}

else {

}

return;

}

&& identity.getType() == "text")) {

localMUCServiceJID_ = service;

localMUCServiceFinderWalker_->endWalk();

break;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

delete walker_;

}

itemsInProgress_ = 0;

walker_ = new DiscoServiceWalker(jid, iqRouter_);

walker_->onServiceFound.connect(boost::bind(&MUCSearchController::handleDiscoServiceFound, this, _1, _2));

}

}

if (isMUC) {

services_.erase(std::remove(services_.begin(), services_.end(), jid), services_.end());

services_.push_back(jid);

serviceDetails_[jid].setName(name);

serviceDetails_[jid].setJID(jid);

serviceDetails_[jid].setComplete(false);

itemsInProgress_++;

GetDiscoItemsRequest::ref discoItemsRequest = GetDiscoItemsRequest::create(jid, iqRouter_);

discoItemsRequest->onResponse.connect(boost::bind(&MUCSearchController::handleRoomsItemsResponse, this, _1, _2, jid));

discoItemsRequest->send();

}

void MUCSearchController::handleDiscoWalkFinished() {

updateInProgressness();

}

void MUCSearchController::handleRoomsItemsResponse(std::shared_ptr<DiscoItems> items, ErrorPayload::ref error, const JID& jid) {

itemsInProgress_--;

updateInProgressness();

if (error) {

handleDiscoError(jid, error);

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void FileTransferController::start(std::string& description) {

fileReadStream = std::make_shared<FileReadBytestream>(boost::filesystem::path(filename));

OutgoingFileTransfer::ref outgoingTransfer = ftManager->createOutgoingFileTransfer(otherParty, boost::filesystem::path(filename), description, fileReadStream);

if (outgoingTransfer) {

}

void FileTransferController::accept(std::string& file) {

IncomingFileTransfer::ref incomingTransfer = std::dynamic_pointer_cast<IncomingFileTransfer>(transfer);

if (incomingTransfer) {

fileWriteStream = std::make_shared<FileWriteBytestream>(boost::filesystem::path(file));

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

catch (boost::archive::archive_exception&) {

configuration = getDefaultConfig();

}

return configuration;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

PlatformXMLParserFactory factory;

auto parser = factory.createXMLParser(this, true);

if (parser->parse(xmlConfig)) {

}

else {

}

}

else {

}

}

if (values_.find(setting.getKey()) != values_.end()) {

std::string value = values_[setting.getKey()];

try {

}

catch(boost::bad_lexical_cast &) {}

}

void XMLSettingsProvider::handleEndElement(const std::string& /*element*/, const std::string& /*ns*/) {

if (level_ == SettingLevel) {

values_[currentElement_] = currentText_;

}

level_--;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

previousStatuses_.push_back(PreviousStatus(boost::trim_copy(bits[1]), type));

}

catch (const boost::bad_lexical_cast& e) {

}

}

}

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

file.close();

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

jidAvatars.insert(std::make_pair(jid, r.first));

}

else if (!r.first.empty() || !r.second.empty()) {

}

}

}

}

catch (...) {

}

}

}

boost::filesystem::create_directories(avatarPath.parent_path());

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

file.write(reinterpret_cast<const char*>(vecptr(avatar)), static_cast<std::streamsize>(avatar.size()));

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

readByteArrayFromFile(data, getAvatarPath(hash));

}

catch (const boost::filesystem::filesystem_error& e) {

}

return data;

}

file.close();

}

catch (...) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

return true;

}

else {

return false;

}

}

file.close();

}

catch (...) {

}

}

if (titleLength == 0 || promptLength == 0) {

int error = GetLastError();

switch (error) {

}

}

if (hstore) {

if (CertCloseStore(hstore, 0) == FALSE) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

text->activateWindow();

}

else {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

if (avatarFile.exists() && !avatarFile.absolutePath().startsWith(":/")) {

QString cacheSubPath = QString("ScaledAvatarCacheV%1/%2").arg(QString::number(QT_SCALED_AVATAR_CACHE_VERSION), QString::number(size));

if (!avatarFile.dir().mkpath(cacheSubPath)) {

return path;

}

QDir targetDir(avatarFile.dir().absoluteFilePath(cacheSubPath));

return path;

}

} else {

}

}

return targetFile;

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void QtSpellCheckerWindow::setActiveLanguage(const std::string& language) {

if (languageItems_.find(language) != languageItems_.end()) {

languageItems_[language]->setSelected(true);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

Log::setLogFile(fileName);

}

catch (...) {

}

}

//TODO this old option can be purged

for (auto&& fontName : fontNames) {

std::string fontPath = std::string(":/") + fontName;

int error = QFontDatabase::addApplicationFont(P2QSTRING(fontPath));

}

#ifdef SWIFTEN_PLATFORM_LINUX

std::string fontPath = std::string(":/themes/Default/Noto/NotoColorEmoji.ttf");

int error = QFontDatabase::addApplicationFont(P2QSTRING(fontPath));

QFont::insertSubstitution(QApplication::font().family(),"NotoColorEmoji");

#endif

#ifdef SWIFTEN_PLATFORM_WINDOWS

std::string stringVal;

std::vector<std::string> segments = String::split(optionString, ',');

switch (intVal) {

case 1: result.useTLS = ClientOptions::NeverUseTLS; break;

case 2: result.useTLS = ClientOptions::UseTLSWhenAvailable; break;

case 3: result.useTLS = ClientOptions::RequireTLS; break;

default:;

}

switch (intVal) {

case 1: result.proxyType = ClientOptions::NoProxy; break;

case 2: result.proxyType = ClientOptions::SystemConfiguredProxy; break;

case 3: result.proxyType = ClientOptions::SOCKS5Proxy; break;

case 4: result.proxyType = ClientOptions::HTTPConnectProxy; break;

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

else {

// Spellchecking is not working, as we did not get a valid checker from the factory. Disable spellchecking.

settings_->storeSetting(QtUISettingConstants::SPELL_CHECKER, false);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

QtUIFactory::~QtUIFactory() {

for (auto chat : chatWindows_) {

}

delete chatWindowFactory_;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void QtWebKitChatView::addMessageTop(std::shared_ptr<ChatSnippet> /* snippet */) {

// TODO: Implement this in a sensible manner later.

}

void QtWebKitChatView::addToDOM(std::shared_ptr<ChatSnippet> snippet) {

rememberScrolledToBottom();

QWebElement ftElement = findElementWithID(document_, "div", id);

if (ftElement.isNull()) {

return;

}

QWebElement progressBar = ftElement.findFirst("div.progressbar");

rememberScrolledToBottom();

QWebElement ftElement = findElementWithID(document_, "div", id);

if (ftElement.isNull()) {

return;

}

void QtWebKitChatView::resetTopInsertPoint() {

// TODO: Implement or refactor later.

}

std::string QtWebKitChatView::addMessage(

}

std::string QtWebKitChatView::addFileTransfer(const std::string& senderName, const std::string& avatarPath, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) {

QString ft_id = QString("ft%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));

QString actionText;

void QtWebKitChatView::setFileTransferWarning(QString id, QString warningText) {

QWebElement ftElement = findElementWithID(document_, "div", id);

if (ftElement.isNull()) {

return;

}

void QtWebKitChatView::removeFileTransferWarning(QString id) {

QWebElement ftElement = findElementWithID(document_, "div", id);

if (ftElement.isNull()) {

return;

}

window_->resendMessage(Q2PSTRING(chatID));

}

else {

}

}

} else if ((keyEvent->key() == Qt::Key_Alt && event->type() == QEvent::KeyRelease && isModifierSinglePressed_)

|| (keyEvent->key() == Qt::Key_Menu)) {

QPoint itemOffset(2,2);

QApplication::postEvent(treeView_, new QContextMenuEvent(QContextMenuEvent::Keyboard, contextMenuPosition, treeView_->mapToGlobal(contextMenuPosition)));

return true;

} else if (keyEvent->key() == Qt::Key_Return) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void QtDynamicGridLayout::moveTab(QtTabWidget* tabWidget, int oldIndex, int newIndex) {

#if QT_VERSION >= 0x040500

movingTab_ = qobject_cast<QtTabbable*>(tabWidget->widget(oldIndex));

if (movingTab_) {

// Install event filter that filters out events issued during the internal movement of the

tabWidget->tabBar()->moveTab(oldIndex, newIndex);

qApp->removeEventFilter(this);

}

movingTab_ = nullptr;

tabWidget->widget(newIndex)->setFocus();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

boost::optional<std::string> newHash = getCombinedAvatarAndCache(jid);

if (newHash != oldHash) {

onAvatarChanged(jid);

}

}

boost::optional<std::string> CombinedAvatarProvider::getCombinedAvatarAndCache(const JID& jid) const {

boost::optional<std::string> hash;

for (size_t i = 0; i < providers.size() && !hash; ++i) {

hash = providers[i]->getAvatarHash(jid);

}

if (hash) {

avatars[jid] = *hash;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

JID from = getAvatarJID(presence->getFrom());

if (update->getPhotoHash().size() != 40) {

return;

}

if (getAvatarHash(from) == update->getPhotoHash()) {

return;

}

if (avatarStorage_->hasAvatar(update->getPhotoHash())) {

setAvatarHash(from, update->getPhotoHash());

}

void VCardUpdateAvatarManager::handleVCardChanged(const JID& from, VCard::ref vCard) {

if (!vCard) {

return;

}

}

void VCardUpdateAvatarManager::setAvatarHash(const JID& from, const std::string& hash) {

avatarHashes_[from] = hash;

onAvatarChanged(from);

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

localString = boost::posix_time::to_simple_string(boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(time));

}

catch(std::out_of_range& exception) {

}

return localString;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

static Log::Severity logLevel = Log::warning;

std::unique_ptr<FILE, Log::LogFileClose> Log::logfile;

Log::Log() {

}

__android_log_print(ANDROID_LOG_VERBOSE, "Swift", stream.str().c_str(), 1);

#else

// Using stdio for thread safety (POSIX file i/o calls are guaranteed to be atomic)

}

else {

}

#endif

}

std::ostringstream& Log::getStream(

int line,

return stream;

}

}

}

}

#pragma once

#include <cstdio>

#include <memory>

#include <sstream>

enum Severity {

error, warning, info, debug

};

Log();

~Log();

std::ostringstream& getStream(

Severity severity,

int line,

static Severity getLogLevel();

static void setLogLevel(Severity level);

static void setLogFile(const std::string& fileName);

private:

struct LogFileClose {

};

std::ostringstream stream;

static std::unique_ptr<FILE, LogFileClose> logfile;

};

}

}

std::shared_ptr<ChatState> statePayload = message->getPayload<ChatState>();

if (statePayload) {

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

authenticationPort(-1) {

#ifdef SWIFTEN_PLATFORM_WIN32

if (WindowsRegistry::isFIPSEnabled()) {

}

#endif

}

}

void ClientSession::handleStreamStart(const ProtocolHeader&) {

state = State::Negotiating;

}

}

}

else if (StreamFeatures* streamFeatures = dynamic_cast<StreamFeatures*>(element.get())) {

if (streamFeatures->hasStartTLS() && stream->supportsTLSEncryption() && useTLS != NeverUseTLS) {

state = State::WaitingForEncrypt;

}

}

else if (std::dynamic_pointer_cast<Compressed>(element)) {

state = State::WaitingForStreamStart;

stream->addZLibCompression();

stream->resetXMPPParser();

continueSessionInitialization();

}

else if (AuthChallenge* challenge = dynamic_cast<AuthChallenge*>(element.get())) {

assert(authenticator);

if (authenticator->setChallenge(challenge->getValue())) {

stream->writeElement(std::make_shared<AuthResponse>(authenticator->getResponse()));

}

}

else if (AuthSuccess* authSuccess = dynamic_cast<AuthSuccess*>(element.get())) {

assert(authenticator);

if (!authenticator->setChallenge(authSuccess->getValue())) {

finishSession(Error::ServerVerificationFailedError);

finishSession(Error::AuthenticationFailedError);

}

else if (dynamic_cast<TLSProceed*>(element.get())) {

state = State::Encrypting;

stream->addTLSEncryption();

}

void ClientSession::handleTLSEncrypted() {

if (!std::dynamic_pointer_cast<BOSHSessionStream>(stream)) {

}

std::vector<Certificate::ref> certificateChain = stream->getPeerCertificateChain();

finishSession(std::shared_ptr<Error>());

}

else {

}

}

error_ = error;

}

else {

}

assert(stream->isOpen());

if (stanzaAckResponder_) {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void ClientSessionStanzaChannel::send(std::shared_ptr<Stanza> stanza) {

if (!isAvailable()) {

return;

}

session->sendStanza(stanza);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

HostAddressPort systemHTTPConnectProxy = networkFactories->getProxyProvider()->getHTTPConnectProxy();

switch (o.proxyType) {

case ClientOptions::NoProxy:

break;

case ClientOptions::SystemConfiguredProxy:

if (systemSOCKS5Proxy.isValid()) {

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), systemSOCKS5Proxy.getAddress().toString(), systemSOCKS5Proxy.getPort()));

}

if (systemHTTPConnectProxy.isValid()) {

proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), systemHTTPConnectProxy.getAddress().toString(), systemHTTPConnectProxy.getPort()));

}

break;

case ClientOptions::SOCKS5Proxy: {

std::string proxyHostname = o.manualProxyHostname.empty() ? systemSOCKS5Proxy.getAddress().toString() : o.manualProxyHostname;

auto proxyPort = systemSOCKS5Proxy.getPort();

if (o.manualProxyPort != -1) {

proxyPort = boost::numeric_cast<unsigned short>(o.manualProxyPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

onDisconnected(boost::optional<ClientError>(ClientError::ConnectionError));

return;

}

}

proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), proxyHostname, proxyPort));

useDirectConnection = false;

break;

}

case ClientOptions::HTTPConnectProxy: {

std::string proxyHostname = o.manualProxyHostname.empty() ? systemHTTPConnectProxy.getAddress().toString() : o.manualProxyHostname;

unsigned short proxyPort = systemHTTPConnectProxy.getPort();

if (o.manualProxyPort != -1) {

proxyPort = boost::numeric_cast<unsigned short>(o.manualProxyPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

onDisconnected(boost::optional<ClientError>(ClientError::ConnectionError));

return;

}

}

proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getDomainNameResolver(), networkFactories->getConnectionFactory(), networkFactories->getTimerFactory(), proxyHostname, proxyPort, o.httpTrafficFilter));

useDirectConnection = false;

break;

port = boost::numeric_cast<unsigned short>(o.manualPort);

}

catch (const boost::numeric::bad_numeric_cast& e) {

onDisconnected(boost::optional<ClientError>(ClientError::ConnectionError));

return;

}

sessionStream_->onDataRead.connect(boost::bind(&CoreClient::handleDataRead, this, _1));

sessionStream_->onDataWritten.connect(boost::bind(&CoreClient::handleDataWritten, this, _1));

if (certificate_ && !certificate_->isNull()) {

sessionStream_->setTLSCertificate(certificate_);

}

boshSessionStream_->open();

void CoreClient::sendData(const std::string& data) {

if (!sessionStream_) {

return;

}

sessionStream_->writeData(data);

void CoreClient::forceReset() {

if (connector_) {

resetConnector();

}

if (sessionStream_ || connection_) {

resetSession();

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void ComponentSessionStanzaChannel::send(std::shared_ptr<Stanza> stanza) {

if (!isAvailable()) {

return;

}

session->sendStanza(stanza);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

CoreComponent::~CoreComponent() {

if (session_ || connection_) {

}

delete iqRouter_;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

requestedDiscoInfos.erase(hash);

if (error || !discoInfo || CapsInfoGenerator("", crypto).generateCapsInfo(*discoInfo.get()).getVersion() != hash) {

if (warnOnInvalidHash && !error && discoInfo) {

}

failingCaps.insert(std::make_pair(from, hash));

std::map<std::string, std::set< std::pair<JID, std::string> > >::iterator i = fallbacks.find(hash);

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void DiscoServiceWalker::beginWalk() {

assert(!active_);

assert(servicesBeingSearched_.empty());

active_ = true;

void DiscoServiceWalker::endWalk() {

if (active_) {

for (auto&& request : pendingDiscoInfoRequests_) {

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoInfoResponse, this, _1, _2, request));

}

}

void DiscoServiceWalker::walkNode(const JID& jid) {

servicesBeingSearched_.insert(jid);

searchedServices_.insert(jid);

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(jid, iqRouter_);

return;

}

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoInfoResponse, this, _1, _2, request));

pendingDiscoInfoRequests_.erase(request);

return;

}

request->onResponse.disconnect(boost::bind(&DiscoServiceWalker::handleDiscoItemsResponse, this, _1, _2, request));

pendingDiscoItemsRequests_.erase(request);

if (error) {

* but I've never seen one in the wild, and it's an easy fix for not looping.

*/

if (std::find(searchedServices_.begin(), searchedServices_.end(), item.getJID()) == searchedServices_.end()) { /* Don't recurse infinitely */

walkNode(item.getJID());

}

}

}

void DiscoServiceWalker::handleDiscoError(const JID& jid, ErrorPayload::ref /*error*/) {

markNodeCompleted(jid);

}

void DiscoServiceWalker::markNodeCompleted(const JID& jid) {

servicesBeingSearched_.erase(jid);

/* All results are in */

if (servicesBeingSearched_.empty()) {

public:

void setName(const std::string& name) {

}

const std::string& getName() const {

ImproperAddressing,

InternalServerError,

InvalidFrom,

InvalidNamespace,

InvalidXML,

NotAuthorized,

SystemShutdown,

UndefinedCondition,

UnsupportedEncoding,

UnsupportedStanzaType,

UnsupportedVersion

};

name(name), description(description), size(size), hash(hash), date(date), algo(algo), supportsRangeRequests(false), rangeOffset(0) {}

void setName(const std::string& name) {

}

const std::string& getName() const {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

file.close();

}

catch (const boost::filesystem::filesystem_error& e) {

}

}

}

}

catch (const boost::filesystem::filesystem_error& e) {

}

return std::shared_ptr<Payload>();

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

std::unique_lock<std::recursive_mutex> lock(isEventInASIOEventLoopMutex_);

isEventInASIOEventLoop_ = false;

}

}

void BoostASIOEventLoop::eventPosted() {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

std::unique_lock<std::recursive_mutex> lock(isEventInCocoaEventLoopMutex_);

isEventInCocoaEventLoop_ = false;

}

}

void CocoaEventLoop::eventPosted() {

/*

* All rights reserved.

* See the COPYING file for more information.

*/

DummyEventLoop::~DummyEventLoop() {

if (hasEvents()) {

}

}

void DummyEventLoop::processEvents() {

while(hasEvents()) {

hasEvents_ = false;

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

event.callback();

}

catch (const std::exception& e) {

}

catch (...) {

}

}

EventLoop::~EventLoop() {

}

// the event loop implementation, then do no handle further events. Instead call

// eventPosted() to continue event handling later.

bool callEventPosted = handlingEvents_;

handlingEvents_ = true;

std::unique_lock<std::recursive_mutex> lock(removeEventsMutex_);

{

{

events_.pop_front();

}

callEventPosted = !events_.empty();

}

}

}

handlingEvents_ = false;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

protected:

/**

* at any point after the virtual \ref eventPosted method has been called.

* This method does not block, except for short-time synchronization.

* If called recursively, the event queue is not further processed. Instead, \ref eventPosted

* is called to notify the implementing event loop of the non-empty event queue.

* as this can lead to an infinite loop.

*/

/**

* The \ref eventPosted virtual method serves as notification for when events are still available in the queue.

* It is called after the first event is posted to an empty queue or after an event has been handled in

*/

virtual void eventPosted() = 0;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

std::unique_lock<std::recursive_mutex> lock(isEventInQtEventLoopMutex_);

isEventInQtEventLoop_ = false;

}

//event->deleteLater(); FIXME: Leak?

return true;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void SimpleEventLoop::runOnce() {

}

void SimpleEventLoop::stop() {

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

std::lock_guard<std::mutex> lock(eventAvailableMutex_);

eventAvailable_ = false;

}

}

void SingleThreadedEventLoop::stop() {

CPPUNIT_TEST(testPost);

CPPUNIT_TEST(testRemove);

CPPUNIT_TEST(testHandleEvent_Recursive);

CPPUNIT_TEST_SUITE_END();

public:

CPPUNIT_ASSERT_EQUAL(1, events_[1]);

}

private:

struct MyEventOwner : public EventOwner {};

void logEvent(int i) {

ClientXMLTracer* tracer = new ClientXMLTracer(client);

client->onConnected.connect(&handleConnected);

errorConnection = client->onDisconnected.connect(&handleDisconnected);

if (!connectHost.empty()) {

std::cout << connectHost << std::endl;

ClientOptions options;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

incomingFileTransfers.push_back(transfer);

std::shared_ptr<FileWriteBytestream> out = std::make_shared<FileWriteBytestream>("out");

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

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void DefaultFileTransferTransporter::startActivatingProxy(const JID& proxyServiceJID) {

// activate proxy

S5BProxyRequest::ref proxyRequest = std::make_shared<S5BProxyRequest>();

proxyRequest->setSID(s5bSessionID);

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

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

}

else {

}

}

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

}

else {

}

}

std::string result;

if (role == Initiator) {

result = getInitiatorCandidateSOCKS5DstAddr();

}

else {

result = getResponderCandidateSOCKS5DstAddr();

}

return result;

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void FailingTransportSession::start() {

onFinished(FileTransferError(FileTransferError::PeerError));

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

}

else {

}

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

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void IncomingJingleFileTransfer::accept(

std::shared_ptr<WriteBytestream> stream,

const FileTransferOptions& options) {

assert(!this->stream);

this->stream = stream;

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

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

if (s5bTransport) {

setTransporter(transporterFactory->createResponderTransporter(

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

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

transporter->startGeneratingLocalCandidates();

}

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

setTransporter(transporterFactory->createResponderTransporter(

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

}

void IncomingJingleFileTransfer::cancel() {

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

}

const std::string& s5bSessionID,

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

const std::string& dstAddr) {

fillCandidateMap(localCandidates, candidates);

void IncomingJingleFileTransfer::handleSessionInfoReceived(JinglePayload::ref jinglePayload) {

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

if (transferHash) {

waitOnHashTimer->stop();

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

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

}

}

else {

}

}

void IncomingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

if (state == Finished) {

return;

}

terminate(JinglePayload::Reason::Success);

}

else {

terminate(JinglePayload::Reason::MediaError);

}

}

void IncomingJingleFileTransfer::checkIfAllDataReceived() {

if (receivedBytes == getFileSizeInBytes()) {

bool hashInfoAvailable = false;

for (const auto& hashElement : hashes) {

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

}

if (!hashInfoAvailable) {

setState(WaitingForHash);

waitOnHashTimer->start();

}

}

}

else if (receivedBytes > getFileSizeInBytes()) {

terminate(JinglePayload::Reason::MediaError);

}

}

void IncomingJingleFileTransfer::handleTransportReplaceReceived(

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

if (state != WaitingForFallbackOrTerminate) {

return;

}

JingleIBBTransportPayload::ref ibbTransport;

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

startTransferring(transporter->createIBBReceiveSession(

ibbTransport->getSessionID(),

session->sendTransportAccept(content, ibbTransport);

}

else {

session->sendTransportReject(content, transport);

}

}

bool IncomingJingleFileTransfer::verifyData() {

if (hashes.empty()) {

return true;

}

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

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

}

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

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

}

else {

return true;

}

}

void IncomingJingleFileTransfer::handleWaitOnHashTimerTicked() {

waitOnHashTimer->stop();

terminate(JinglePayload::Reason::Success);

}

}

void IncomingJingleFileTransfer::setState(State state) {

this->state = state;

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

}

void IncomingJingleFileTransfer::setFinishedState(

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

this->state = Finished;

onStateChanged(type);

onFinished(error);

transportSession->stop();

transportSession.reset();

break;

}

if (state != Initial) {

removeTransporter();

}

void IncomingJingleFileTransfer::startTransferViaRemoteCandidate() {

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

setState(WaitingForPeerProxyActivate);

}

void IncomingJingleFileTransfer::startTransferViaLocalCandidate() {

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

setState(WaitingForLocalProxyActivate);

}

void IncomingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {

this->transportSession = transportSession;

transferFinishedConnection = transportSession->onFinished.connect(

}

void IncomingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {

if (state != Finished) {

session->sendTerminate(reason);

std::string IncrementalBytestreamHashCalculator::getSHA1String() {

assert(sha1Hasher);

}

std::string IncrementalBytestreamHashCalculator::getMD5String() {

assert(md5Hasher);

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

void JingleFileTransfer::handleRemoteTransportCandidateSelectFinished(

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

ourCandidateChoice = candidate;

ourCandidateSelectFinished = true;

// decide on candidates according to http://xmpp.org/extensions/xep-0260.html#complete

void JingleFileTransfer::decideOnCandidates() {

if (!ourCandidateSelectFinished || !theirCandidateSelectFinished) {

return;

}

if (!ourCandidateChoice && !theirCandidateChoice) {

fallback();

}

else if (ourCandidateChoice && !theirCandidateChoice) {

startTransferViaRemoteCandidate();

}

else if (theirCandidateChoice && !ourCandidateChoice) {

startTransferViaLocalCandidate();

}

else {

SWIFT_LOG(debug) << "Choosing between candidates "

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

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

startTransferViaRemoteCandidate();

}

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

startTransferViaLocalCandidate();

}

else {

if (hasPriorityOnCandidateTie()) {

startTransferViaRemoteCandidate();

}

else {

startTransferViaLocalCandidate();

}

}

void JingleFileTransfer::handleProxyActivateFinished(

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

if (error) {

JingleS5BTransportPayload::ref proxyError = std::make_shared<JingleS5BTransportPayload>();

proxyError->setSessionID(s5bSessionID);

proxyError->setProxyError(true);

void JingleFileTransfer::handleTransportInfoReceived(

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

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

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

theirCandidateSelectFinished = true;

if (!s5bPayload->hasCandidateError()) {

auto theirCandidate = localCandidates.find(s5bPayload->getCandidateUsed());

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

terminate(JinglePayload::Reason::GeneralError);

return;

}

decideOnCandidates();

}

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

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

startTransferring(createRemoteCandidateSession());

}

else {

terminate(JinglePayload::Reason::GeneralError);

}

}

else if (s5bPayload->hasProxyError()) {

fallback();

}

else {

}

}

else {

}

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

LocalJingleTransportCandidateGenerator::~LocalJingleTransportCandidateGenerator() {

}

void LocalJingleTransportCandidateGenerator::start() {

}

}

else {

if (s5bServerResourceUser_) {

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

}

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

}

void OutgoingJingleFileTransfer::start() {

if (state != Initial) {

return;

}

}

void OutgoingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {

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

session->sendTerminate(reason);

const JingleContentID&,

JingleDescription::ref,

JingleTransportPayload::ref transportPayload) {

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

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

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

}

else {

fallback();

}

}

void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {

stopAll();

if (state == WaitForTermination) {

}

void OutgoingJingleFileTransfer::handleTransportAcceptReceived(const JingleContentID&, JingleTransportPayload::ref transport) {

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

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

}

else {

terminate(JinglePayload::Reason::FailedTransport);

}

}

void OutgoingJingleFileTransfer::handleTransportRejectReceived(const JingleContentID &, std::shared_ptr<JingleTransportPayload>) {

terminate(JinglePayload::Reason::UnsupportedTransports);

}

void OutgoingJingleFileTransfer::sendSessionInfoHash() {

JingleFileTransferHash::ref hashElement = std::make_shared<JingleFileTransferHash>();

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

void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(

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

fillCandidateMap(localCandidates, candidates);

JingleTransportPayload::ref transport;

if (candidates.empty()) {

JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();

ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

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

s5bTransport->setDstAddr(dstAddr);

for (auto&& candidate : candidates) {

s5bTransport->addCandidate(candidate);

}

transport = s5bTransport;

}

void OutgoingJingleFileTransfer::fallback() {

if (options.isInBandAllowed()) {

JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();

ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);

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

session->sendTransportReplace(contentID, ibbTransport);

}

else {

terminate(JinglePayload::Reason::ConnectivityError);

}

}

void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {

if (error) {

terminate(JinglePayload::Reason::ConnectivityError);

}

void OutgoingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {

this->transportSession = transportSession;

processedBytesConnection = transportSession->onBytesSent.connect(

void OutgoingJingleFileTransfer::setInternalState(State state) {

this->state = state;

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

}

void OutgoingJingleFileTransfer::setFinishedState(

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

this->state = Finished;

onStateChanged(type);

onFinished(error);

}

void OutgoingJingleFileTransfer::stopAll() {

switch (state) {

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

case WaitingForAccept: break;

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

break;

case WaitForTermination:

break;

}

if (state != Initial) {

removeTransporter();

}

void OutgoingJingleFileTransfer::startTransferViaRemoteCandidate() {

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

setInternalState(WaitingForPeerProxyActivate);

}

void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {

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

setInternalState(WaitingForLocalProxyActivate);

void OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout() {

assert(state == WaitForTermination);

waitForRemoteTermination->stop();

terminate(JinglePayload::Reason::MediaError);

}