1 files changed, 8 insertions, 7 deletions
diff --git a/Swift/Controllers/MainController.cpp b/Swift/Controllers/MainController.cpp
index 4f869a7..d60bcbb 100644
--- a/Swift/Controllers/MainController.cpp
+++ b/Swift/Controllers/MainController.cpp
@@ -127,87 +127,88 @@ MainController::MainController(
 
 	notifier_ = new TogglableNotifier(notifier);
 	notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));
 	eventController_ = new EventController();
 	eventController_->onEventQueueLengthChange.connect(boost::bind(&MainController::handleEventQueueLengthChange, this, _1));
 
 	systemTrayController_ = new SystemTrayController(eventController_, systemTray);
 	loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);
 	loginWindow_->setShowNotificationToggle(!notifier->isExternallyConfigured());
 	soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings);
 
 	xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);
 
 	std::string selectedLoginJID = settings_->getSetting(SettingConstants::LAST_LOGIN_JID);
 	bool loginAutomatically = settings_->getSetting(SettingConstants::LOGIN_AUTOMATICALLY);
 	std::string cachedPassword;
 	std::string cachedCertificate;
 	bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);
 	if (!eagle) {
 		foreach (std::string profile, settings->getAvailableProfiles()) {
 			ProfileSettingsProvider profileSettings(profile, settings);
 			std::string password = profileSettings.getStringSetting("pass");
 			std::string certificate = profileSettings.getStringSetting("certificate");
 			std::string jid = profileSettings.getStringSetting("jid");
 			loginWindow_->addAvailableAccount(jid, password, certificate);
 			if (jid == selectedLoginJID) {
 				cachedPassword = password;
 				cachedCertificate = certificate;
 			}
 		}
 		loginWindow_->selectUser(selectedLoginJID);
 		loginWindow_->setLoginAutomatically(loginAutomatically);
 	}
 
 
-	loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4, _5));
+	loginWindow_->onLoginRequest.connect(boost::bind(&MainController::handleLoginRequest, this, _1, _2, _3, _4, _5, _6));
 	loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&MainController::handlePurgeSavedLoginRequest, this, _1));
 	loginWindow_->onCancelLoginRequest.connect(boost::bind(&MainController::handleCancelLoginRequest, this));
 	loginWindow_->onQuitRequest.connect(boost::bind(&MainController::handleQuitRequest, this));
 
 	idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));
 	idleDetector_->onIdleChanged.connect(boost::bind(&MainController::handleInputIdleChanged, this, _1));
 
 	xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);
 
 	fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);
 
 	settings_->onSettingChanged.connect(boost::bind(&MainController::handleSettingChanged, this, _1));
 
 	if (loginAutomatically) {
 		profileSettings_ = new ProfileSettingsProvider(selectedLoginJID, settings_);
-		handleLoginRequest(selectedLoginJID, cachedPassword, cachedCertificate, true, true);
+		/* FIXME: deal with autologin with a cert*/
+		handleLoginRequest(selectedLoginJID, cachedPassword, cachedCertificate, CertificateWithKey::ref(), true, true);
 	} else {
 		profileSettings_ = NULL;
 	}
 }
 
 MainController::~MainController() {
 	idleDetector_->onIdleChanged.disconnect(boost::bind(&MainController::handleInputIdleChanged, this, _1));
 
 	purgeCachedCredentials();
 	//setManagersOffline();
 	eventController_->disconnectAll();
 
 	resetClient();
 	delete fileTransferListController_;
 	delete xmlConsoleController_;
 	delete xmppURIController_;
 	delete soundEventController_;
 	delete systemTrayController_;
 	delete eventController_;
 	delete notifier_;
 	delete uiEventStream_;
 }
 
 void MainController::purgeCachedCredentials() {
 	safeClear(password_);
 }
 
 void MainController::resetClient() {
 	purgeCachedCredentials();
 	resetCurrentError();
 	resetPendingReconnects();
 	vCardPhotoHash_.clear();
 	delete contactEditController_;
 	contactEditController_ = NULL;
 	delete profileController_;
@@ -384,136 +385,136 @@ void MainController::sendPresence(boost::shared_ptr<Presence> presence) {
 	}
 	client_->getPresenceSender()->sendPresence(presence);
 	if (presence->getType() == Presence::Unavailable) {
 		logout();
 	}
 }
 
 void MainController::handleInputIdleChanged(bool idle) {
 	if (!statusTracker_) {
 		//Haven't logged in yet.
 		return;
 	}
 
 	if (settings_->getSetting(SettingConstants::IDLE_GOES_OFFLINE)) {
 		if (idle) {
 			logout();
 		}
 	}
 	else {
 		if (idle) {
 			if (statusTracker_->goAutoAway()) {
 				if (client_ && client_->isAvailable()) {
 					sendPresence(statusTracker_->getNextPresence());
 				}
 			}
 		} else {
 			if (statusTracker_->goAutoUnAway()) {
 				if (client_ && client_->isAvailable()) {
 					sendPresence(statusTracker_->getNextPresence());
 				}
 			}
 		}
 	}
 }
 
-void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificateFile, bool remember, bool loginAutomatically) {
+void MainController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, bool remember, bool loginAutomatically) {
 	jid_ = JID(username);
 	if (!jid_.isValid() || jid_.getNode().empty()) {
 		loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'alice@wonderland.lit'"));
 		loginWindow_->setIsLoggingIn(false);
 	} else {
 		loginWindow_->setMessage("");
 		loginWindow_->setIsLoggingIn(true);
 		profileSettings_ = new ProfileSettingsProvider(username, settings_);
 		if (!settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {
 			profileSettings_->storeString("jid", username);
-			profileSettings_->storeString("certificate", certificateFile);
+			profileSettings_->storeString("certificate", certificatePath);
 			profileSettings_->storeString("pass", (remember || loginAutomatically) ? password : "");
 			settings_->storeSetting(SettingConstants::LAST_LOGIN_JID, username);
 			settings_->storeSetting(SettingConstants::LOGIN_AUTOMATICALLY, loginAutomatically);
 			loginWindow_->addAvailableAccount(profileSettings_->getStringSetting("jid"), profileSettings_->getStringSetting("pass"), profileSettings_->getStringSetting("certificate"));
 		}
 
 		password_ = password;
-		certificateFile_ = certificateFile;
+		certificate_ = certificate;
 		performLoginFromCachedCredentials();
 	}
 }
 
 void MainController::handlePurgeSavedLoginRequest(const std::string& username) {
 	settings_->removeProfile(username);
 	loginWindow_->removeAvailableAccount(username);
 }
 
 void MainController::performLoginFromCachedCredentials() {
 	if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS) && password_.empty()) {
 		/* Then we can't try to login again. */
 		return;
 	}
 	/* If we logged in with a bare JID, and we have a full bound JID, re-login with the
 	 * bound JID to try and keep dynamically assigned resources */
 	JID clientJID = jid_;
 	if (boundJID_.isValid() && jid_.isBare() && boundJID_.toBare() == jid_) {
 		clientJID = boundJID_;
 	}
 
 	if (!statusTracker_) {
 		statusTracker_  = new StatusTracker();
 	}
 	if (!clientInitialized_) {
 		storages_ = storagesFactory_->createStorages(jid_.toBare());
 		certificateStorage_ = certificateStorageFactory_->createCertificateStorage(jid_.toBare());
 		certificateTrustChecker_ = new CertificateStorageTrustChecker(certificateStorage_);
 
 		client_ = boost::make_shared<Swift::Client>(clientJID, createSafeByteArray(password_.c_str()), networkFactories_, storages_);
 		clientInitialized_ = true;
 		client_->setCertificateTrustChecker(certificateTrustChecker_);
 		client_->onDataRead.connect(boost::bind(&XMLConsoleController::handleDataRead, xmlConsoleController_, _1));
 		client_->onDataWritten.connect(boost::bind(&XMLConsoleController::handleDataWritten, xmlConsoleController_, _1));
 		client_->onDisconnected.connect(boost::bind(&MainController::handleDisconnected, this, _1));
 		client_->onConnected.connect(boost::bind(&MainController::handleConnected, this));
 
 		client_->setSoftwareVersion(CLIENT_NAME, buildVersion);
 
 		client_->getVCardManager()->onVCardChanged.connect(boost::bind(&MainController::handleVCardReceived, this, _1, _2));
 		presenceNotifier_ = new PresenceNotifier(client_->getStanzaChannel(), notifier_, client_->getMUCRegistry(), client_->getAvatarManager(), client_->getNickResolver(), client_->getPresenceOracle(), networkFactories_->getTimerFactory());
 		presenceNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));
 		eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());
 		eventNotifier_->onNotificationActivated.connect(boost::bind(&MainController::handleNotificationClicked, this, _1));
-		if (!certificateFile_.empty()) {
-			client_->setCertificate(certificateFile_);
+		if (certificate_ && !certificate_->isNull()) {
+			client_->setCertificate(certificate_);
 		}
 		boost::shared_ptr<Presence> presence(new Presence());
 		presence->setShow(static_cast<StatusShow::Type>(profileSettings_->getIntSetting("lastShow", StatusShow::Online)));
 		presence->setStatus(profileSettings_->getStringSetting("lastStatus"));
 		statusTracker_->setRequestedPresence(presence);
 	} else {
 		/* In case we're in the middle of another login, make sure they don't overlap */
 		client_->disconnect();
 	}
 	systemTrayController_->setConnecting();
 	if (rosterController_) {
 		rosterController_->getWindow()->setConnecting();
 	}
 	ClientOptions clientOptions;
 	bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);
 	clientOptions.forgetPassword = eagle;
 	clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : ClientOptions::UseTLSWhenAvailable;
 	/*if (clientJID.getDomain() == "doomsong.co.uk") {
 		clientOptions.boshURL = URL("https", "channels.doomsong.co.uk", 11443, "http-bind/");
 		clientOptions.boshHTTPConnectProxyURL = URL("http", "squidproxy.doomsong.co.uk", 8123, "");
 	}*/
 	client_->connect(clientOptions);
 }
 
 void MainController::handleDisconnected(const boost::optional<ClientError>& error) {
 	if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {
 		purgeCachedCredentials();
 	}
 	if (quitRequested_) {
 		resetClient();
 		loginWindow_->quit();
 	}
 	else if (error) {
 		std::string message;
 		std::string certificateErrorMessage;