/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Client/CoreClient.h>

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/Network/ChainedConnector.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Swiften/Session/BasicSessionStream.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

#include <Swiften/Network/SOCKS5ProxiedConnectionFactory.h>

#include <Swiften/Network/HTTPConnectProxiedConnectionFactory.h>

namespace Swift {

CoreClient::CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories) : jid_(jid), password_(password), networkFactories(networkFactories), disconnectRequested_(false), certificateTrustChecker(NULL) {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.connect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.connect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

iqRouter_ = new IQRouter(stanzaChannel_);

iqRouter_->setJID(jid);

}

CoreClient::~CoreClient() {

forceReset();

delete iqRouter_;

stanzaChannel_->onAvailableChanged.disconnect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

stanzaChannel_->onMessageReceived.disconnect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.disconnect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.disconnect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

delete stanzaChannel_;

}

void CoreClient::connect(const ClientOptions& o) {

SWIFT_LOG(debug) << "Connecting" << std::endl;

options = o;

connect(jid_.getDomain());

}

void CoreClient::connect(const std::string& host) {

forceReset();

SWIFT_LOG(debug) << "Connecting to host " << host << std::endl;

disconnectRequested_ = false;

assert(!connector_);

assert(proxyConnectionFactories.empty());

}

}

std::vector<ConnectionFactory*> connectionFactories(proxyConnectionFactories);

connectionFactories.push_back(networkFactories->getConnectionFactory());

connector_ = boost::make_shared<ChainedConnector>(host, networkFactories->getDomainNameResolver(), connectionFactories, networkFactories->getTimerFactory());

connector_->onConnectFinished.connect(boost::bind(&CoreClient::handleConnectorFinished, this, _1));

connector_->setTimeoutMilliseconds(60*1000);

connector_->start();

}

void CoreClient::handleConnectorFinished(boost::shared_ptr<Connection> connection) {

resetConnector();

if (!connection) {

if (options.forgetPassword) {

purgePassword();

}

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

}

else {

assert(!connection_);

connection_ = connection;

assert(!sessionStream_);

sessionStream_ = boost::make_shared<BasicSessionStream>(ClientStreamType, connection_, getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory());

if (!certificate_.empty()) {

sessionStream_->setTLSCertificate(PKCS12Certificate(certificate_, password_));

}

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

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

session_ = ClientSession::create(jid_, sessionStream_);

session_->setCertificateTrustChecker(certificateTrustChecker);

session_->setUseStreamCompression(options.useStreamCompression);

session_->setAllowPLAINOverNonTLS(options.allowPLAINWithoutTLS);

switch(options.useTLS) {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Network/BoostNetworkFactories.h>

#include <Swiften/Network/BoostTimerFactory.h>

#include <Swiften/Network/BoostConnectionFactory.h>

#include <Swiften/Network/PlatformDomainNameResolver.h>

#include <Swiften/Network/BoostConnectionServerFactory.h>

#include <Swiften/Network/PlatformNATTraversalWorker.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

#include <Swiften/Network/NullNATTraverser.h>

#include <Swiften/TLS/PlatformTLSFactories.h>

namespace Swift {

BoostNetworkFactories::BoostNetworkFactories(EventLoop* eventLoop) {

timerFactory = new BoostTimerFactory(ioServiceThread.getIOService(), eventLoop);

connectionFactory = new BoostConnectionFactory(ioServiceThread.getIOService(), eventLoop);

domainNameResolver = new PlatformDomainNameResolver(eventLoop);

connectionServerFactory = new BoostConnectionServerFactory(ioServiceThread.getIOService(), eventLoop);

#ifdef SWIFT_EXPERIMENTAL_FT

natTraverser = new PlatformNATTraversalWorker(eventLoop);

#else

natTraverser = new NullNATTraverser(eventLoop);

#endif

xmlParserFactory = new PlatformXMLParserFactory();

tlsFactories = new PlatformTLSFactories();

}

BoostNetworkFactories::~BoostNetworkFactories() {

delete tlsFactories;

delete xmlParserFactory;

delete natTraverser;

delete connectionServerFactory;

delete domainNameResolver;

delete connectionFactory;

delete timerFactory;

}

}

class BoostNetworkFactories : public NetworkFactories {

public:

BoostNetworkFactories(EventLoop* eventLoop);

~BoostNetworkFactories();

virtual TimerFactory* getTimerFactory() const {

return timerFactory;

}

virtual ConnectionFactory* getConnectionFactory() const {

return connectionFactory;

}

BoostIOServiceThread* getIOServiceThread() {

return &ioServiceThread;

}

DomainNameResolver* getDomainNameResolver() const {

return domainNameResolver;

}

ConnectionServerFactory* getConnectionServerFactory() const {

return connectionServerFactory;

}

NATTraverser* getNATTraverser() const {

return natTraverser;

}

virtual XMLParserFactory* getXMLParserFactory() const {

return xmlParserFactory;

}

virtual TLSContextFactory* getTLSContextFactory() const;

private:

BoostIOServiceThread ioServiceThread;

TimerFactory* timerFactory;

ConnectionFactory* connectionFactory;

DomainNameResolver* domainNameResolver;

ConnectionServerFactory* connectionServerFactory;

NATTraverser* natTraverser;

XMLParserFactory* xmlParserFactory;

PlatformTLSFactories* tlsFactories;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

namespace Swift {

class TimerFactory;

class ConnectionFactory;

class DomainNameResolver;

class ConnectionServerFactory;

class NATTraverser;

class XMLParserFactory;

class TLSContextFactory;

class CertificateFactory;

/**

* An interface collecting network factories.

*/

class NetworkFactories {

public:

virtual ~NetworkFactories();

virtual TimerFactory* getTimerFactory() const = 0;

virtual ConnectionFactory* getConnectionFactory() const = 0;

virtual DomainNameResolver* getDomainNameResolver() const = 0;

virtual ConnectionServerFactory* getConnectionServerFactory() const = 0;

virtual NATTraverser* getNATTraverser() const = 0;

virtual XMLParserFactory* getXMLParserFactory() const = 0;

virtual TLSContextFactory* getTLSContextFactory() const = 0;

};

}