cachedPassword = password;

cachedCertificate = certificate;

}

}

loginWindow_->selectUser(selectedLoginJID);

loginWindow_->setLoginAutomatically(loginAutomatically);

}

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_);

} else {

profileSettings_ = NULL;

}

}

MainController::~MainController() {

idleDetector_->onIdleChanged.disconnect(boost::bind(&MainController::handleInputIdleChanged, this, _1));

purgeCachedCredentials();

if (statusTracker_->goAutoUnAway()) {

if (client_ && client_->isAvailable()) {

sendPresence(statusTracker_->getNextPresence());

}

}

}

}

}

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("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;

performLoginFromCachedCredentials();

}

}

void MainController::handlePurgeSavedLoginRequest(const std::string& username) {

settings_->removeProfile(username);

loginWindow_->removeAvailableAccount(username);

}

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));

}

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();

}

URIHandler* uriHandler,

IdleDetector* idleDetector,

bool useDelayForLatency);

~MainController();

private:

void resetClient();

void handleConnected();

void handleCancelLoginRequest();

void handleQuitRequest();

void handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText);

void handleDisconnected(const boost::optional<ClientError>& error);

void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo>, ErrorPayload::ref);

void handleEventQueueLengthChange(int count);

void handleVCardReceived(const JID& j, VCard::ref vCard);

void handleSettingChanged(const std::string& settingPath);

void handlePurgeSavedLoginRequest(const std::string& username);

ProfileController* profileController_;

ContactEditController* contactEditController_;

JID jid_;

JID boundJID_;

SystemTrayController* systemTrayController_;

SoundEventController* soundEventController_;

XMPPURIController* xmppURIController_;

std::string vCardPhotoHash_;

std::string password_;

boost::shared_ptr<ErrorEvent> lastDisconnectError_;

bool useDelayForLatency_;

UserSearchController* userSearchControllerChat_;

UserSearchController* userSearchControllerAdd_;

int timeBeforeNextReconnect_;

Timer::ref reconnectTimer_;

StatusTracker* statusTracker_;

bool myStatusLooksOnline_;

bool quitRequested_;

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <string>

#include <Swiften/TLS/Certificate.h>

namespace Swift {

class MainWindow;

class LoginWindow {

public:

virtual ~LoginWindow() {};

virtual void selectUser(const std::string&) = 0;

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

virtual void setShowNotificationToggle(bool) = 0;

virtual void setMessage(const std::string&) = 0;

virtual void setIsLoggingIn(bool loggingIn) = 0;

virtual void addAvailableAccount(const std::string& defaultJID, const std::string& defaultPassword, const std::string& defaultCertificate) = 0;

virtual void removeAvailableAccount(const std::string& jid) = 0;

virtual void setLoginAutomatically(bool loginAutomatically) = 0;

virtual void quit() = 0;

/** Blocking request whether a cert should be permanently trusted.*/

virtual bool askUserToTrustCertificatePermanently(const std::string& message, Certificate::ref) = 0;

boost::signal<void ()> onCancelLoginRequest;

boost::signal<void ()> onQuitRequest;

boost::signal<void (const std::string&)> onPurgeSavedLoginRequest;

};

/*

* Copyright (c) 2012 Isode Limited, London, England.

* Licensed under the simplified BSD license.

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

*/

#include <string>

#define SECURITY_WIN32

#include <Windows.h>

#include <WinCrypt.h>

#include <cryptuiapi.h>

namespace Swift {

#define cert_dlg_title L"TLS Client Certificate Selection"

#define cert_dlg_prompt L"Select a certificate to use for authentication"

/////Hmm, maybe we should not exlude the "location" column

#define exclude_columns CRYPTUI_SELECT_LOCATION_COLUMN \

|CRYPTUI_SELECT_INTENDEDUSE_COLUMN

CertFreeCertificateContext(cert);

return ret;

} else {

return "";

}

}

}

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

*/

#pragma once

#include <string>

namespace Swift {

std::string selectCAPICertificate();

}

#include <Swiften/Base/Paths.h>

#include <QtAboutWidget.h>

#include <QtSwiftUtil.h>

#include <QtMainWindow.h>

#include <QtUtilities.h>

#ifdef HAVE_SCHANNEL

#include "CAPICertificateSelector.h"

#endif

namespace Swift{

QtLoginWindow::QtLoginWindow(UIEventStream* uiEventStream, SettingsProvider* settings) : QMainWindow(), settings_(settings) {

uiEventStream_ = uiEventStream;

setWindowTitle("Swift");

#ifndef Q_WS_MAC

setWindowIcon(QIcon(":/logo-icon-16.png"));

msgBox.setWindowTitle(tr("Confirm terms of use"));

msgBox.setText("");

msgBox.setInformativeText(P2QSTRING(banner));

msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);

msgBox.setDefaultButton(QMessageBox::No);

if (msgBox.exec() != QMessageBox::Yes) {

return;

}

}

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) { /* Mustn't remember logins */

username_->clearEditText();

password_->setText("");

}

} else {

onCancelLoginRequest();

}

}

void QtLoginWindow::setLoginAutomatically(bool loginAutomatically) {

loginAutomatically_->setChecked(loginAutomatically);

}

void QtLoginWindow::handleCertficateChecked(bool checked) {

if (checked) {

#ifdef HAVE_SCHANNEL

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#else

certificateFile_ = QFileDialog::getOpenFileName(this, tr("Select an authentication certificate"), QString(), QString("*.cert;*.p12;*.pfx"));

if (certificateFile_.isEmpty()) {

certificateButton_->setChecked(false);

}

#endif

myenv.Append(CPPPATH = ["."])

if env["PLATFORM"] == "win32" :

#myenv["LINKFLAGS"] = ["/SUBSYSTEM:CONSOLE"]

myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])

myenv.Append(LIBS = "qtmain")

if myenv.get("HAVE_SCHANNEL", 0) :

myenv.Append(LIBS = "Cryptui")

myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateDefaultTheme(myenv.Dir("#/Swift/resources/themes/Default"))))

sources = [

"main.cpp",

"QtAboutWidget.cpp",

"QtAvatarWidget.cpp",

"QtUIFactory.cpp",

"QtChatWindowFactory.cpp",