5 files changed, 15 insertions, 6 deletions
diff --git a/Swiften/Client/CoreClient.cpp b/Swiften/Client/CoreClient.cpp
index 22e3612..2a66905 100644
--- a/Swiften/Client/CoreClient.cpp
+++ b/Swiften/Client/CoreClient.cpp
@@ -1,132 +1,129 @@
 /*
  * 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/PlatformTLSFactories.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/PlatformProxyProvider.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);
-	tlsFactories = new PlatformTLSFactories();
 }
 
 CoreClient::~CoreClient() {
 	forceReset();
-	delete tlsFactories;
 	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());
 	PlatformProxyProvider proxyProvider;
 	if(proxyProvider.getSOCKS5Proxy().isValid()) {
 		proxyConnectionFactories.push_back(new SOCKS5ProxiedConnectionFactory(networkFactories->getConnectionFactory(), proxyProvider.getSOCKS5Proxy()));
 	}
 	if(proxyProvider.getHTTPConnectProxy().isValid()) {
 		proxyConnectionFactories.push_back(new HTTPConnectProxiedConnectionFactory(networkFactories->getConnectionFactory(), proxyProvider.getHTTPConnectProxy()));
 	}
 	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(), tlsFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory());
+		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) {
 			case ClientOptions::UseTLSWhenAvailable:
 				session_->setUseTLS(ClientSession::UseTLSWhenAvailable);
 				break;
 			case ClientOptions::NeverUseTLS:
 				session_->setUseTLS(ClientSession::NeverUseTLS);
 				break;
 			case ClientOptions::RequireTLS:
 				session_->setUseTLS(ClientSession::RequireTLS);
 				break;
 		}
 		session_->setUseAcks(options.useAcks);
 		stanzaChannel_->setSession(session_);
 		session_->onFinished.connect(boost::bind(&CoreClient::handleSessionFinished, this, _1));
 		session_->onNeedCredentials.connect(boost::bind(&CoreClient::handleNeedCredentials, this));
 		session_->start();
 	}
 }
 
 void CoreClient::disconnect() {
 	// FIXME: We should be able to do without this boolean. We just have to make sure we can tell the difference between
 	// connector finishing without a connection due to an error or because of a disconnect.
 	disconnectRequested_ = true;
 	if (session_ && !session_->isFinished()) {
 		session_->finish();
diff --git a/Swiften/Client/CoreClient.h b/Swiften/Client/CoreClient.h
index ad31e72..3c089c1 100644
--- a/Swiften/Client/CoreClient.h
+++ b/Swiften/Client/CoreClient.h
@@ -1,68 +1,67 @@
 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <Swiften/Base/boost_bsignals.h>
 
 #include <Swiften/Entity/Entity.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Client/ClientError.h>
 #include <Swiften/Client/ClientOptions.h>
 #include <Swiften/Base/SafeByteArray.h>
 
 namespace Swift {
 	class ChainedConnector;
 	class Message;
 	class Presence;
 	class Error;
 	class IQRouter;
 	class TLSContextFactory;
 	class ConnectionFactory;
 	class Connection;
 	class TimerFactory;
 	class ClientSession;
 	class StanzaChannel;
 	class Stanza;
 	class BasicSessionStream;
-	class PlatformTLSFactories;
 	class CertificateTrustChecker;
 	class NetworkFactories;
 	class ClientSessionStanzaChannel;
 
 	/** 
 	 * The central class for communicating with an XMPP server.
 	 *
 	 * This class is responsible for setting up the connection with the XMPP
 	 * server, authenticating, and initializing the session.
 	 *
 	 * This class can be used directly in your application, although the Client
 	 * subclass provides more functionality and interfaces, and is better suited
 	 * for most needs.
 	 */
 	class CoreClient : public Entity {
 		public: 
 			/**
 			 * Constructs a client for the given JID with the given password.
 			 * The given eventLoop will be used to post events to.
 			 */
 			CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories);
 			~CoreClient();
 
 			void setCertificate(const std::string& certificate);
 
 			/**
 			 * Connects the client to the server.
 			 *
 			 * After the connection is established, the client will set 
 			 * initialize the stream and authenticate.
 			 */
 			void connect(const ClientOptions& = ClientOptions());
 
 			/**
 			 * Disconnects the client from the server.
@@ -190,44 +189,43 @@ namespace Swift {
 
 			NetworkFactories* getNetworkFactories() const {
 				return networkFactories;
 			}
 
 			/**
 			 * Called before onConnected signal is emmitted.
 			 */
 			virtual void handleConnected() {};
 
 		private:
 			void handleConnectorFinished(boost::shared_ptr<Connection>);
 			void handleStanzaChannelAvailableChanged(bool available);
 			void handleSessionFinished(boost::shared_ptr<Error>);
 			void handleNeedCredentials();
 			void handleDataRead(const SafeByteArray&);
 			void handleDataWritten(const SafeByteArray&);
 			void handlePresenceReceived(boost::shared_ptr<Presence>);
 			void handleMessageReceived(boost::shared_ptr<Message>);
 			void handleStanzaAcked(boost::shared_ptr<Stanza>);
 			void purgePassword();
 
 			void resetConnector();
 			void resetSession();
 			void forceReset();
 
 		private:
 			JID jid_;
 			SafeByteArray password_;
 			NetworkFactories* networkFactories;
 			ClientSessionStanzaChannel* stanzaChannel_;
 			IQRouter* iqRouter_;
 			ClientOptions options;
 			boost::shared_ptr<ChainedConnector> connector_;
 			std::vector<ConnectionFactory*> proxyConnectionFactories;
-			PlatformTLSFactories* tlsFactories;
 			boost::shared_ptr<Connection> connection_;
 			boost::shared_ptr<BasicSessionStream> sessionStream_;
 			boost::shared_ptr<ClientSession> session_;
 			std::string certificate_;
 			bool disconnectRequested_;
 			CertificateTrustChecker* certificateTrustChecker;
 	};
 }
diff --git a/Swiften/Network/BoostNetworkFactories.cpp b/Swiften/Network/BoostNetworkFactories.cpp
index 56be2b7..030fd49 100644
--- a/Swiften/Network/BoostNetworkFactories.cpp
+++ b/Swiften/Network/BoostNetworkFactories.cpp
@@ -1,40 +1,47 @@
 /*
  * 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();
+}
+
+TLSContextFactory* BoostNetworkFactories::getTLSContextFactory() const {
+	return tlsFactories->getTLSContextFactory();
 }
 
 BoostNetworkFactories::~BoostNetworkFactories() {
+	delete tlsFactories;
 	delete xmlParserFactory;
 	delete natTraverser;
 	delete connectionServerFactory;
 	delete domainNameResolver;
 	delete connectionFactory;
 	delete timerFactory;
 }
 
 }
diff --git a/Swiften/Network/BoostNetworkFactories.h b/Swiften/Network/BoostNetworkFactories.h
index c9ecb59..8f2b17a 100644
--- a/Swiften/Network/BoostNetworkFactories.h
+++ b/Swiften/Network/BoostNetworkFactories.h
@@ -1,58 +1,62 @@
 /*
  * Copyright (c) 2010 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swiften/Network/NetworkFactories.h>
 #include <Swiften/Network/BoostIOServiceThread.h>
 
 namespace Swift {
 	class EventLoop;
 	class NATTraverser;
+	class PlatformTLSFactories;
 
 	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;
 	};
 }
diff --git a/Swiften/Network/NetworkFactories.h b/Swiften/Network/NetworkFactories.h
index 42c9f6a..2404460 100644
--- a/Swiften/Network/NetworkFactories.h
+++ b/Swiften/Network/NetworkFactories.h
@@ -1,31 +1,34 @@
 /*
  * 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;
 	};
 }