+/*

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/AccountController.h>

+

+#include <cstdlib>

+#include <memory>

+

+#include <boost/bind.hpp>

+#include <boost/lexical_cast.hpp>

+

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/String.h>

+#include <Swiften/Base/format.h>

+#include <Swiften/Client/Client.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Client/StanzaChannel.h>

+#include <Swiften/Client/Storages.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+#include <Swiften/Disco/CapsInfoGenerator.h>

+#include <Swiften/Disco/ClientDiscoManager.h>

+#include <Swiften/Disco/GetDiscoInfoRequest.h>

+#include <Swiften/Elements/ChatState.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Elements/VCardUpdate.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Network/NetworkFactories.h>

+#include <Swiften/Network/TimerFactory.h>

+#include <Swiften/Presence/PresenceSender.h>

+#include <Swiften/Queries/Requests/EnableCarbonsRequest.h>

+#include <Swiften/StringCodecs/Base64.h>

+#include <Swiften/StringCodecs/Hexify.h>

+#include <Swiften/VCards/GetVCardRequest.h>

+#include <Swiften/VCards/VCardManager.h>

+

+#ifdef SWIFTEN_PLATFORM_WIN32

+#include <Swiften/SASL/WindowsAuthentication.h>

+#endif

+

+#include <Swift/Controllers/AdHocManager.h>

+#include <Swift/Controllers/BlockListController.h>

+#include <Swift/Controllers/BuildVersion.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/Chat/ChatsManager.h>

+#include <Swift/Controllers/Chat/MUCController.h>

+#include <Swift/Controllers/Chat/UserSearchController.h>

+#include <Swift/Controllers/ContactEditController.h>

+#include <Swift/Controllers/ContactSuggester.h>

+#include <Swift/Controllers/ContactsFromXMPPRoster.h>

+#include <Swift/Controllers/EventNotifier.h>

+#include <Swift/Controllers/EventWindowController.h>

+#include <Swift/Controllers/FdpFormSubmitController.h>

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

+#include <Swift/Controllers/FileTransferListController.h>

+#include <Swift/Controllers/Highlighting/HighlightEditorController.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/HistoryController.h>

+#include <Swift/Controllers/HistoryViewController.h>

+#include <Swift/Controllers/Intl.h>

+#include <Swift/Controllers/PresenceNotifier.h>

+#include <Swift/Controllers/ProfileController.h>

+#include <Swift/Controllers/Roster/RosterController.h>

+#include <Swift/Controllers/SettingConstants.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/ShowProfileController.h>

+#include <Swift/Controllers/SoundEventController.h>

+#include <Swift/Controllers/SoundPlayer.h>

+#include <Swift/Controllers/StatusTracker.h>

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+#include <Swift/Controllers/Storages/CertificateStorageTrustChecker.h>

+#include <Swift/Controllers/Storages/StoragesFactory.h>

+#include <Swift/Controllers/SystemTray.h>

+#include <Swift/Controllers/SystemTrayController.h>

+#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIInterfaces/LoginWindow.h>

+#include <Swift/Controllers/UIInterfaces/LoginWindowFactory.h>

+#include <Swift/Controllers/UIInterfaces/MainWindow.h>

+#include <Swift/Controllers/UIInterfaces/UIFactory.h>

+#include <Swift/Controllers/WhiteboardManager.h>

+#include <Swift/Controllers/XMLConsoleController.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+#include <Swift/Controllers/XMPPURIController.h>

+

+#include <SwifTools/Dock/Dock.h>

+#include <SwifTools/Idle/IdleDetector.h>

+#include <SwifTools/Notifier/TogglableNotifier.h>

+

+namespace Swift {

+

+static const std::string CLIENT_NAME = "Swift";

+static const std::string CLIENT_NODE = "http://swift.im";

+

+

+AccountController::AccountController(

+ EventLoop* eventLoop,

+ NetworkFactories* networkFactories,

+ UIFactory* uiFactories,

+ SettingsProvider* settings,

+ SystemTray* systemTray,

+ SoundPlayer* soundPlayer,

+ StoragesFactory* storagesFactory,

+ CertificateStorageFactory* certificateStorageFactory,

+ Dock* dock,

+ Notifier* notifier,

+ URIHandler* uriHandler,

+ IdleDetector* idleDetector,

+ const std::map<std::string, std::string>& emoticons,

+ bool useDelayForLatency) :

+ eventLoop_(eventLoop),

+ networkFactories_(networkFactories),

+ uiFactory_(uiFactories),

+ storagesFactory_(storagesFactory),

+ certificateStorageFactory_(certificateStorageFactory),

+ settings_(settings),

+ uriHandler_(uriHandler),

+ idleDetector_(idleDetector),

+ loginWindow_(nullptr) ,

+ useDelayForLatency_(useDelayForLatency),

+ ftOverview_(nullptr),

+ emoticons_(emoticons),

+ fdpFormSubmitController_(nullptr) {

+ storages_ = nullptr;

+ certificateStorage_ = nullptr;

+ certificateTrustChecker_ = nullptr;

+ statusTracker_ = nullptr;

+ presenceNotifier_ = nullptr;

+ eventNotifier_ = nullptr;

+ rosterController_ = nullptr;

+ chatsManager_ = nullptr;

+ historyController_ = nullptr;

+ historyViewController_ = nullptr;

+ eventWindowController_ = nullptr;

+ profileController_ = nullptr;

+ blockListController_ = nullptr;

+ showProfileController_ = nullptr;

+ contactEditController_ = nullptr;

+ userSearchControllerChat_ = nullptr;

+ userSearchControllerAdd_ = nullptr;

+ userSearchControllerInvite_ = nullptr;

+ contactsFromRosterProvider_ = nullptr;

+ contactSuggesterWithoutRoster_ = nullptr;

+ contactSuggesterWithRoster_ = nullptr;

+ whiteboardManager_ = nullptr;

+ adHocManager_ = nullptr;

+ quitRequested_ = false;

+ clientInitialized_ = false;

+ offlineRequested_ = false;

+

+ timeBeforeNextReconnect_ = -1;

+ dock_ = dock;

+ uiEventStream_ = new UIEventStream();

+

+ notifier_ = new TogglableNotifier(notifier);

+ notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

+ eventController_ = new EventController();

+ eventController_->onEventQueueLengthChange.connect(boost::bind(&AccountController::handleEventQueueLengthChange, this, _1));

+

+ systemTrayController_ = new SystemTrayController(eventController_, systemTray);

+ loginWindow_ = uiFactory_->createLoginWindow(uiEventStream_);

+ loginWindow_->setShowNotificationToggle(!notifier->isExternallyConfigured());

+

+ highlightManager_ = new HighlightManager(settings_);

+ highlightEditorController_ = new HighlightEditorController(uiEventStream_, uiFactory_, highlightManager_);

+

+ soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings, highlightManager_);

+

+ xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

+

+ loginWindow_->onLoginRequest.connect(boost::bind(&AccountController::handleLoginRequest, this, _1, _2, _3, _4, _5, _6, _7));

+ loginWindow_->onPurgeSavedLoginRequest.connect(boost::bind(&AccountController::handlePurgeSavedLoginRequest, this, _1));

+ loginWindow_->onCancelLoginRequest.connect(boost::bind(&AccountController::handleCancelLoginRequest, this));

+ loginWindow_->onQuitRequest.connect(boost::bind(&AccountController::handleQuitRequest, this));

+

+ idleDetector_->setIdleTimeSeconds(settings->getSetting(SettingConstants::IDLE_TIMEOUT));

+ idleDetector_->onIdleChanged.connect(boost::bind(&AccountController::handleInputIdleChanged, this, _1));

+

+ xmlConsoleController_ = new XMLConsoleController(uiEventStream_, uiFactory_);

+

+ fileTransferListController_ = new FileTransferListController(uiEventStream_, uiFactory_);

+

+ settings_->onSettingChanged.connect(boost::bind(&AccountController::handleSettingChanged, this, _1));

+

+}

+

+AccountController::~AccountController() {

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

+

+ purgeCachedCredentials();

+ //setManagersOffline();

+ eventController_->disconnectAll();

+

+ resetClient();

+ delete highlightEditorController_;

+ delete highlightManager_;

+ delete fileTransferListController_;

+ delete xmlConsoleController_;

+ delete xmppURIController_;

+ delete soundEventController_;

+ delete systemTrayController_;

+ delete eventController_;

+ delete notifier_;

+ delete uiEventStream_;

+}

+

+void AccountController::purgeCachedCredentials() {

+ safeClear(password_);

+}

+

+void AccountController::resetClient() {

+ purgeCachedCredentials();

+ resetCurrentError();

+ resetPendingReconnects();

+ vCardPhotoHash_.clear();

+ delete contactEditController_;

+ contactEditController_ = nullptr;

+ delete profileController_;

+ profileController_ = nullptr;

+ delete showProfileController_;

+ showProfileController_ = nullptr;

+ delete eventWindowController_;

+ eventWindowController_ = nullptr;

+ delete chatsManager_;

+ chatsManager_ = nullptr;

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ delete historyViewController_;

+ historyViewController_ = nullptr;

+ delete historyController_;

+ historyController_ = nullptr;

+#endif

+ fileTransferListController_->setFileTransferOverview(nullptr);

+ delete ftOverview_;

+ ftOverview_ = nullptr;

+ delete blockListController_;

+ blockListController_ = nullptr;

+ delete rosterController_;

+ rosterController_ = nullptr;

+ chattables_.reset();

+ delete eventNotifier_;

+ eventNotifier_ = nullptr;

+ delete presenceNotifier_;

+ presenceNotifier_ = nullptr;

+ delete certificateTrustChecker_;

+ certificateTrustChecker_ = nullptr;

+ delete certificateStorage_;

+ certificateStorage_ = nullptr;

+ delete storages_;

+ storages_ = nullptr;

+ delete statusTracker_;

+ statusTracker_ = nullptr;

+ delete profileSettings_;

+ profileSettings_ = nullptr;

+ delete userSearchControllerChat_;

+ userSearchControllerChat_ = nullptr;

+ delete userSearchControllerAdd_;

+ userSearchControllerAdd_ = nullptr;

+ delete userSearchControllerInvite_;

+ userSearchControllerInvite_ = nullptr;

+ delete contactSuggesterWithoutRoster_;

+ contactSuggesterWithoutRoster_ = nullptr;

+ delete contactSuggesterWithRoster_;

+ contactSuggesterWithRoster_ = nullptr;

+ delete contactsFromRosterProvider_;

+ contactsFromRosterProvider_ = nullptr;

+ delete adHocManager_;

+ adHocManager_ = nullptr;

+ delete whiteboardManager_;

+ whiteboardManager_ = nullptr;

+ clientInitialized_ = false;

+}

+

+void AccountController::handleSettingChanged(const std::string& settingPath) {

+ if (settingPath == SettingConstants::SHOW_NOTIFICATIONS.getKey()) {

+ notifier_->setPersistentEnabled(settings_->getSetting(SettingConstants::SHOW_NOTIFICATIONS));

+ }

+}

+

+void AccountController::resetPendingReconnects() {

+ timeBeforeNextReconnect_ = -1;

+ if (reconnectTimer_) {

+ reconnectTimer_->stop();

+ reconnectTimer_.reset();

+ }

+ resetCurrentError();

+}

+

+void AccountController::resetCurrentError() {

+ if (lastDisconnectError_) {

+ lastDisconnectError_->conclude();

+ lastDisconnectError_ = std::shared_ptr<ErrorEvent>();

+ }

+}

+

+void AccountController::handleConnected() {

+ boundJID_ = client_->getJID();

+ resetCurrentError();

+ resetPendingReconnects();

+

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ purgeCachedCredentials();

+ }

+

+ bool freshLogin = rosterController_ == nullptr;

+ myStatusLooksOnline_ = true;

+ if (freshLogin) {

+ profileController_ = new ProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

+ showProfileController_ = new ShowProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

+ ftOverview_ = new FileTransferOverview(client_->getFileTransferManager());

+ fileTransferListController_->setFileTransferOverview(ftOverview_);

+ chattables_ = std::make_unique<Chattables>();

+ rosterController_ = new RosterController(boundJID_, client_->getRoster(), client_->getAvatarManager(), uiFactory_, client_->getNickManager(), client_->getNickResolver(), client_->getPresenceOracle(), client_->getSubscriptionManager(), eventController_, uiEventStream_, client_->getIQRouter(), settings_, client_->getEntityCapsProvider(), client_->getClientBlockListManager(), client_->getVCardManager(), *chattables_);

+ rosterController_->onChangeStatusRequest.connect(boost::bind(&AccountController::handleChangeStatusRequest, this, _1, _2));

+ rosterController_->onSignOutRequest.connect(boost::bind(&AccountController::signOut, this));

+ rosterController_->getWindow()->onShowCertificateRequest.connect(boost::bind(&AccountController::handleShowCertificateRequest, this));

+

+ blockListController_ = new BlockListController(client_->getClientBlockListManager(), uiEventStream_, uiFactory_, eventController_);

+

+ contactEditController_ = new ContactEditController(rosterController_, client_->getVCardManager(), uiFactory_, uiEventStream_);

+ whiteboardManager_ = new WhiteboardManager(uiFactory_, uiEventStream_, client_->getNickResolver(), client_->getWhiteboardSessionManager());

+

+ /* Doing this early as an ordering fix. Various things later will

+ * want to have the user's nick available and this means it will

+ * be before they receive stanzas that need it (e.g. bookmarks).*/

+ client_->getVCardManager()->requestOwnVCard();

+

+ contactSuggesterWithoutRoster_ = new ContactSuggester();

+ contactSuggesterWithRoster_ = new ContactSuggester();

+

+ userSearchControllerInvite_ = new UserSearchController(UserSearchController::Type::InviteToChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ historyController_ = new HistoryController(storages_->getHistoryStorage());

+ historyViewController_ = new HistoryViewController(jid_, uiEventStream_, historyController_, client_->getNickResolver(), client_->getAvatarManager(), client_->getPresenceOracle(), uiFactory_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager());

+#else

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, nullptr, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, client_->getVCardManager(), *chattables_);

+#endif

+ contactsFromRosterProvider_ = new ContactsFromXMPPRoster(client_->getRoster(), client_->getAvatarManager(), client_->getPresenceOracle());

+ contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(contactsFromRosterProvider_);

+ highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);

+

+ client_->onMessageReceived.connect(boost::bind(&ChatsManager::handleIncomingMessage, chatsManager_, _1));

+ chatsManager_->setAvatarManager(client_->getAvatarManager());

+

+ eventWindowController_ = new EventWindowController(eventController_, uiFactory_);

+

+ loginWindow_->morphInto(rosterController_->getWindow());

+

+ DiscoInfo discoInfo;

+ discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

+ discoInfo.addFeature(DiscoInfo::ChatStatesFeature);

+ discoInfo.addFeature(DiscoInfo::SecurityLabelsFeature);

+ discoInfo.addFeature(DiscoInfo::MessageCorrectionFeature);

+#ifdef SWIFT_EXPERIMENTAL_FT

+ discoInfo.addFeature(DiscoInfo::JingleFeature);

+ discoInfo.addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

+#endif

+#ifdef SWIFT_EXPERIMENTAL_WB

+ discoInfo.addFeature(DiscoInfo::WhiteboardFeature);

+#endif

+ discoInfo.addFeature(DiscoInfo::MessageDeliveryReceiptsFeature);

+ client_->getDiscoManager()->setCapsNode(CLIENT_NODE);

+ client_->getDiscoManager()->setDiscoInfo(discoInfo);

+

+ userSearchControllerChat_ = new UserSearchController(UserSearchController::Type::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);

+ userSearchControllerAdd_ = new UserSearchController(UserSearchController::Type::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle(), profileSettings_);

+ adHocManager_ = new AdHocManager(JID(boundJID_.getDomain()), uiFactory_, client_->getIQRouter(), uiEventStream_, rosterController_->getWindow());

+

+ chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));

+ }

+ loginWindow_->setIsLoggingIn(false);

+

+ client_->requestRoster();

+

+ GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(boundJID_.getDomain()), client_->getIQRouter());

+ discoInfoRequest->onResponse.connect(boost::bind(&AccountController::handleServerDiscoInfoResponse, this, _1, _2));

+ discoInfoRequest->send();

+

+ client_->getVCardManager()->requestOwnVCard();

+

+ rosterController_->setJID(boundJID_);

+ rosterController_->setEnabled(true);

+ rosterController_->getWindow()->setStreamEncryptionStatus(client_->isStreamEncrypted());

+ profileController_->setAvailable(true);

+ contactEditController_->setAvailable(true);

+ /* Send presence later to catch all the incoming presences. */

+ sendPresence(statusTracker_->getNextPresence());

+

+ /* Enable chats last of all, so rejoining MUCs has the right sent presence */

+ assert(chatsManager_);

+ chatsManager_->setOnline(true);

+ adHocManager_->setOnline(true);

+}

+

+void AccountController::handleEventQueueLengthChange(size_t count) {

+ dock_->setNumberOfPendingMessages(count);

+}

+

+void AccountController::reconnectAfterError() {

+ if (reconnectTimer_) {

+ reconnectTimer_->stop();

+ }

+ performLoginFromCachedCredentials();

+}

+

+void AccountController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {

+ std::shared_ptr<Presence> presence(new Presence());

+ if (show == StatusShow::None) {

+ // Note: this is misleading, None doesn't mean unavailable on the wire.

+ presence->setType(Presence::Unavailable);

+ resetPendingReconnects();

+ myStatusLooksOnline_ = false;

+ offlineRequested_ = true;

+ }

+ else {

+ offlineRequested_ = false;

+ presence->setShow(show);

+ }

+ presence->setStatus(statusText);

+ statusTracker_->setRequestedPresence(presence);

+ if (presence->getType() != Presence::Unavailable) {

+ profileSettings_->storeInt("lastShow", presence->getShow());

+ profileSettings_->storeString("lastStatus", presence->getStatus());

+ }

+ if (presence->getType() != Presence::Unavailable && !client_->isAvailable()) {

+ performLoginFromCachedCredentials();

+ } else {

+ sendPresence(presence);

+ }

+}

+

+void AccountController::sendPresence(std::shared_ptr<Presence> presence) {

+ rosterController_->getWindow()->setMyStatusType(presence->getShow());

+ rosterController_->getWindow()->setMyStatusText(presence->getStatus());

+ systemTrayController_->setMyStatusType(presence->getShow());

+ notifier_->setTemporarilyDisabled(presence->getShow() == StatusShow::DND);

+

+ // Add information and send

+ presence->updatePayload(std::make_shared<VCardUpdate>(vCardPhotoHash_));

+ client_->getPresenceSender()->sendPresence(presence);

+ if (presence->getType() == Presence::Unavailable) {

+ logout();

+ }

+}

+

+void AccountController::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(idleDetector_->getIdleTimeSeconds())) {

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

+ sendPresence(statusTracker_->getNextPresence());

+ }

+ }

+ } else {

+ if (statusTracker_->goAutoUnAway()) {

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

+ sendPresence(statusTracker_->getNextPresence());

+ }

+ }

+ }

+ }

+}

+

+void AccountController::handleShowCertificateRequest() {

+ std::vector<Certificate::ref> chain = client_->getStanzaChannel()->getPeerCertificateChain();

+ rosterController_->getWindow()->openCertificateDialog(chain);

+}

+

+void AccountController::handleLoginRequest(const std::string &username, const std::string &password, const std::string& certificatePath, CertificateWithKey::ref certificate, const ClientOptions& options, bool remember, bool loginAutomatically) {

+ jid_ = JID(username);

+ if (options.singleSignOn && (!jid_.isValid() || !jid_.getNode().empty())) {

+ loginWindow_->setMessage(QT_TRANSLATE_NOOP("", "User address invalid. User address should be of the form 'wonderland.lit'"));

+ loginWindow_->setIsLoggingIn(false);

+ } else if (!options.singleSignOn && (!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 {

+#ifdef SWIFTEN_PLATFORM_WIN32

+ if (options.singleSignOn) {

+ std::string userName;

+ std::string clientName;

+ std::string serverName;

+ std::shared_ptr<boost::system::error_code> errorCode = getUserNameEx(userName, clientName, serverName);

+

+ if (!errorCode) {

+ /* Create JID using the Windows logon name and user provided domain name */

+ jid_ = JID(clientName, username);

+ }

+ else {

+ loginWindow_->setMessage(str(format(QT_TRANSLATE_NOOP("", "Error obtaining Windows user name (%1%)")) % errorCode->message()));

+ loginWindow_->setIsLoggingIn(false);

+ return;

+ }

+ }

+#endif

+

+ loginWindow_->setMessage("");

+ loginWindow_->setIsLoggingIn(true);

+ profileSettings_ = new ProfileSettingsProvider(username, settings_);

+ if (!settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ profileSettings_->storeString("jid", username);

+ profileSettings_->storeString("certificate", certificatePath);

+ profileSettings_->storeString("pass", (remember || loginAutomatically) ? password : "");

+ std::string optionString = serializeClientOptions(options);

+ profileSettings_->storeString("options", optionString);

+ profileSettings_->storeInt("enabled", 1);

+ loginWindow_->addAvailableAccount(profileSettings_->getStringSetting("jid"), profileSettings_->getStringSetting("pass"), profileSettings_->getStringSetting("certificate"), options);

+ }

+

+ password_ = password;

+ certificate_ = certificate;

+ clientOptions_ = options;

+ performLoginFromCachedCredentials();

+ }

+}

+

+void AccountController::handlePurgeSavedLoginRequest(const std::string& username) {

+ settings_->removeProfile(username);

+ loginWindow_->removeAvailableAccount(username);

+}

+

+void AccountController::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_ = std::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(&AccountController::handleDisconnected, this, _1));

+ client_->onConnected.connect(boost::bind(&AccountController::handleConnected, this));

+

+ client_->setSoftwareVersion(CLIENT_NAME, buildVersion);

+

+ client_->getVCardManager()->onVCardChanged.connect(boost::bind(&AccountController::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(&AccountController::handleNotificationClicked, this, _1));

+ eventNotifier_ = new EventNotifier(eventController_, notifier_, client_->getAvatarManager(), client_->getNickResolver());

+ eventNotifier_->onNotificationActivated.connect(boost::bind(&AccountController::handleNotificationClicked, this, _1));

+ if (certificate_) {

+ client_->setCertificate(certificate_);

+ }

+ std::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);

+ fdpFormSubmitController_ = std::make_unique<FdpFormSubmitController>(jid_, client_->getIQRouter(), uiEventStream_, uiFactory_);

+ } 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 = clientOptions_;

+ bool eagle = settings_->getSetting(SettingConstants::FORGET_PASSWORDS);

+ clientOptions.forgetPassword = eagle;

+ clientOptions.useTLS = eagle ? ClientOptions::RequireTLS : clientOptions_.useTLS;

+ client_->connect(clientOptions);

+}

+

+void AccountController::handleDisconnected(const boost::optional<ClientError>& error) {

+ if (rosterController_) {

+ rosterController_->getWindow()->setStreamEncryptionStatus(false);

+ }

+ if (adHocManager_) {

+ adHocManager_->setOnline(false);

+ }

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ purgeCachedCredentials();

+ }

+ if (quitRequested_) {

+ resetClient();

+ loginWindow_->quit();

+ }

+ else if (error) {

+ std::string message;

+ std::string certificateErrorMessage;

+ bool forceSignout = false;

+ switch(error->getType()) {

+ case ClientError::UnknownError: message = QT_TRANSLATE_NOOP("", "Unknown Error"); break;

+ case ClientError::DomainNameResolveError: message = QT_TRANSLATE_NOOP("", "Unable to find server"); break;

+ case ClientError::ConnectionError: message = QT_TRANSLATE_NOOP("", "Error connecting to server"); break;

+ case ClientError::ConnectionReadError: message = QT_TRANSLATE_NOOP("", "Error while receiving server data"); break;

+ case ClientError::ConnectionWriteError: message = QT_TRANSLATE_NOOP("", "Error while sending data to the server"); break;

+ case ClientError::XMLError: message = QT_TRANSLATE_NOOP("", "Error parsing server data"); break;

+ case ClientError::AuthenticationFailedError: message = QT_TRANSLATE_NOOP("", "Login/password invalid"); break;

+ case ClientError::CompressionFailedError: message = QT_TRANSLATE_NOOP("", "Error while compressing stream"); break;

+ case ClientError::ServerVerificationFailedError: message = QT_TRANSLATE_NOOP("", "Server verification failed"); break;

+ case ClientError::NoSupportedAuthMechanismsError: message = QT_TRANSLATE_NOOP("", "Authentication mechanisms not supported"); break;

+ case ClientError::UnexpectedElementError: message = QT_TRANSLATE_NOOP("", "Unexpected response"); break;

+ case ClientError::ResourceBindError: message = QT_TRANSLATE_NOOP("", "Error binding resource"); break;

+ case ClientError::SessionStartError: message = QT_TRANSLATE_NOOP("", "Error starting session"); break;

+ case ClientError::StreamError: message = QT_TRANSLATE_NOOP("", "Stream error"); break;

+ case ClientError::TLSError: message = QT_TRANSLATE_NOOP("", "Encryption error"); break;

+ case ClientError::ClientCertificateLoadError: message = QT_TRANSLATE_NOOP("", "Error loading certificate (Invalid file or password?)"); break;

+ case ClientError::ClientCertificateError: message = QT_TRANSLATE_NOOP("", "Certificate not authorized"); break;

+ case ClientError::CertificateCardRemoved: message = QT_TRANSLATE_NOOP("", "Certificate card removed"); forceSignout = true; break;

+

+ case ClientError::UnknownCertificateError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unknown certificate"); break;

+ case ClientError::CertificateExpiredError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has expired"); break;

+ case ClientError::CertificateNotYetValidError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not yet valid"); break;

+ case ClientError::CertificateSelfSignedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is self-signed"); break;

+ case ClientError::CertificateRejectedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has been rejected"); break;

+ case ClientError::CertificateUntrustedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not trusted"); break;

+ case ClientError::InvalidCertificatePurposeError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate cannot be used for encrypting your connection"); break;

+ case ClientError::CertificatePathLengthExceededError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate path length constraint exceeded"); break;

+ case ClientError::InvalidCertificateSignatureError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid certificate signature"); break;

+ case ClientError::InvalidCAError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Invalid Certificate Authority"); break;

+ case ClientError::InvalidServerIdentityError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate does not match the host identity"); break;

+ case ClientError::RevokedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has been revoked"); break;

+ case ClientError::RevocationCheckFailedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unable to determine certificate revocation state"); break;

+ }

+ bool forceReconnectAfterCertificateTrust = false;

+ if (!certificateErrorMessage.empty()) {

+ std::vector<Certificate::ref> certificates = certificateTrustChecker_->getLastCertificateChain();

+ if (!certificates.empty() && loginWindow_->askUserToTrustCertificatePermanently(certificateErrorMessage, certificates)) {

+ certificateStorage_->addCertificate(certificates[0]);

+ forceReconnectAfterCertificateTrust = true;

+ }

+ else {

+ message = QT_TRANSLATE_NOOP("", "Certificate error");

+ }

+ }

+

+ if (!message.empty() && error->getErrorCode()) {

+ message = str(format(QT_TRANSLATE_NOOP("", "%1% (%2%)")) % message % error->getErrorCode()->message());

+ }

+

+ if (forceReconnectAfterCertificateTrust && settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ forceReconnectAfterCertificateTrust = false;

+ forceSignout = true;

+ message = QT_TRANSLATE_NOOP("", "Re-enter credentials and retry");

+ }

+

+ if (forceReconnectAfterCertificateTrust) {

+ performLoginFromCachedCredentials();

+ }

+ else if (forceSignout || !rosterController_) { //hasn't been logged in yet or permanent error

+ signOut();

+ loginWindow_->setMessage(message);

+ loginWindow_->setIsLoggingIn(false);

+ } else {

+ logout();

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%. To reconnect, Sign Out and provide your password again.")) % jid_.getDomain() % message);

+ } else {

+ if (!offlineRequested_) {

+ setReconnectTimer();

+ }

+ if (lastDisconnectError_) {

+ message = str(format(QT_TRANSLATE_NOOP("", "Reconnect to %1% failed: %2%. Will retry in %3% seconds.")) % jid_.getDomain() % message % std::to_string(timeBeforeNextReconnect_));

+ lastDisconnectError_->conclude();

+ } else {

+ message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%.")) % jid_.getDomain() % message);

+ }

+ lastDisconnectError_ = std::make_shared<ErrorEvent>(JID(jid_.getDomain()), message);

+ eventController_->handleIncomingEvent(lastDisconnectError_);

+ }

+ }

+ }

+ else if (!rosterController_) { //hasn't been logged in yet

+ loginWindow_->setIsLoggingIn(false);

+ }

+}

+

+void AccountController::setReconnectTimer() {

+ if (timeBeforeNextReconnect_ < 0) {

+ timeBeforeNextReconnect_ = 1;

+ } else {

+ timeBeforeNextReconnect_ = timeBeforeNextReconnect_ >= 150 ? 300 : timeBeforeNextReconnect_ * 2; // Randomly selected by roll of a die, as required by 3920bis

+ }

+ if (reconnectTimer_) {

+ reconnectTimer_->stop();

+ }

+ reconnectTimer_ = networkFactories_->getTimerFactory()->createTimer(timeBeforeNextReconnect_ * 1000);

+ reconnectTimer_->onTick.connect(boost::bind(&AccountController::reconnectAfterError, this));

+ reconnectTimer_->start();

+}

+

+void AccountController::handleCancelLoginRequest() {

+ signOut();

+}

+

+void AccountController::signOut() {

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ purgeCachedCredentials();

+ }

+ profileSettings_->storeInt("enabled", 0);

+ eventController_->clear();

+ logout();

+ loginWindow_->loggedOut();

+ resetClient();

+}

+

+void AccountController::logout() {

+ if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

+ purgeCachedCredentials();

+ }

+ systemTrayController_->setMyStatusType(StatusShow::None);

+ if (clientInitialized_ /*&& client_->isAvailable()*/) {

+ client_->disconnect();

+ }

+ if (rosterController_ && myStatusLooksOnline_) {

+ rosterController_->getWindow()->setMyStatusType(StatusShow::None);

+ rosterController_->getWindow()->setMyStatusText("");

+ myStatusLooksOnline_ = false;

+ }

+ setManagersOffline();

+}

+

+void AccountController::setManagersOffline() {

+ if (chatsManager_) {

+ chatsManager_->setOnline(false);

+ }

+ if (rosterController_) {

+ rosterController_->setEnabled(false);

+ }

+ if (profileController_) {

+ profileController_->setAvailable(false);

+ }

+ if (contactEditController_) {

+ contactEditController_->setAvailable(false);

+ }

+}

+

+void AccountController::handleServerDiscoInfoResponse(std::shared_ptr<DiscoInfo> info, ErrorPayload::ref error) {

+ if (!error) {

+ chatsManager_->setServerDiscoInfo(info);

+ adHocManager_->setServerDiscoInfo(info);

+ if (info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

+ rosterController_->getWindow()->setBlockingCommandAvailable(true);

+ rosterController_->initBlockingCommand();

+ }

+ if (info->hasFeature(DiscoInfo::MessageCarbonsFeature)) {

+ enableMessageCarbons();

+ }

+ }

+}

+

+void AccountController::enableMessageCarbons() {

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

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

+ if (error) {

+ SWIFT_LOG(warning) << "Failed to enable carbons.";

+ }

+ else {

+ SWIFT_LOG(debug) << "Successfully enabled carbons.";

+ }

+ enableCarbonsRequestHandlerConnection_.disconnect();

+ });

+ enableCarbonsRequest->send();

+}

+

+void AccountController::handleVCardReceived(const JID& jid, VCard::ref vCard) {

+ if (!jid.equals(jid_, JID::WithoutResource) || !vCard) {

+ return;

+ }

+ std::string hash;

+ if (!vCard->getPhoto().empty()) {

+ hash = Hexify::hexify(networkFactories_->getCryptoProvider()->getSHA1Hash(vCard->getPhoto()));

+ }

+ if (hash != vCardPhotoHash_) {

+ vCardPhotoHash_ = hash;

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

+ sendPresence(statusTracker_->getNextPresence());

+ }

+ }

+}

+

+void AccountController::handleNotificationClicked(const JID& jid) {

+ assert(chatsManager_);

+ if (clientInitialized_) {

+ if (client_->getMUCRegistry()->isMUC(jid)) {

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(jid));

+ }

+ else {

+ uiEventStream_->send(std::make_shared<RequestChatUIEvent>(jid));

+ }

+ }

+}

+

+void AccountController::handleQuitRequest() {

+ if (client_ && client_->isActive()) {

+ quitRequested_ = true;

+ client_->disconnect();

+ }

+ else {

+ resetClient();

+ loginWindow_->quit();

+ }

+}

+

+//FIXME: Switch all this to boost::serialise

+

+#define SERIALIZE_BOOL(option) result += options.option ? "1" : "0"; result += ",";

+#define SERIALIZE_INT(option) result += boost::lexical_cast<std::string>(options.option); result += ",";

+#define SERIALIZE_STRING(option) result += Base64::encode(createByteArray(options.option)); result += ",";

+#define SERIALIZE_SAFE_STRING(option) result += safeByteArrayToString(Base64::encode(options.option)); result += ",";

+#define SERIALIZE_URL(option) SERIALIZE_STRING(option.toString())

+

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

+ std::string result;

+ SERIALIZE_BOOL(useStreamCompression)

+ switch (options.useTLS) {

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

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

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

+ }

+ result += ",";

+ SERIALIZE_BOOL(allowPLAINWithoutTLS)

+ SERIALIZE_BOOL(useStreamResumption)

+ SERIALIZE_BOOL(useAcks)

+ SERIALIZE_STRING(manualHostname)

+ SERIALIZE_INT(manualPort)

+ switch (options.proxyType) {

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

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

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

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

+ }

+ result += ",";

+ SERIALIZE_STRING(manualProxyHostname)

+ SERIALIZE_INT(manualProxyPort)

+ SERIALIZE_URL(boshURL)

+ SERIALIZE_URL(boshHTTPConnectProxyURL)

+ SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthID)

+ SERIALIZE_SAFE_STRING(boshHTTPConnectProxyAuthPassword)

+ SERIALIZE_BOOL(tlsOptions.schannelTLS1_0Workaround)

+ SERIALIZE_BOOL(singleSignOn)

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <map>

+#include <memory>

+#include <string>

+#include <vector>

+

+#include <boost/signals2.hpp>

+

+#include <Swiften/Client/ClientError.h>

+#include <Swiften/Client/ClientXMLTracer.h>

+#include <Swiften/Elements/CapsInfo.h>

+#include <Swiften/Elements/DiscoInfo.h>

+#include <Swiften/Elements/ErrorPayload.h>

+#include <Swiften/Elements/Presence.h>

+#include <Swiften/Elements/VCard.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/Network/Timer.h>

+

+#include <Swift/Controllers/ProfileSettingsProvider.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

+

+namespace Swift {

+ class IdleDetector;

+ class UIFactory;

+ class EventLoop;

+ class Client;

+ class Chattables;

+ class ChatController;

+ class ChatsManager;

+ class CertificateStorageFactory;

+ class CertificateStorage;

+ class CertificateStorageTrustChecker;

+ class EventController;

+ class MainWindow;

+ class RosterController;

+ class LoginWindow;

+ class EventLoop;

+ class MUCController;

+ class Notifier;

+ class ProfileController;

+ class ShowProfileController;

+ class ContactEditController;

+ class TogglableNotifier;

+ class PresenceNotifier;

+ class EventNotifier;

+ class SystemTray;

+ class SystemTrayController;

+ class SoundEventController;

+ class SoundPlayer;

+ class XMLConsoleController;

+ class HistoryViewController;

+ class HistoryController;

+ class FileTransferListController;

+ class UIEventStream;

+ class EventWindowFactory;

+ class EventWindowController;

+ class MUCSearchController;

+ class UserSearchController;

+ class StatusTracker;

+ class Dock;

+ class Storages;

+ class StoragesFactory;

+ class NetworkFactories;

+ class URIHandler;

+ class XMPPURIController;

+ class AdHocManager;

+ class AdHocCommandWindowFactory;

+ class FileTransferOverview;

+ class WhiteboardManager;

+ class HighlightManager;

+ class HighlightEditorController;

+ class BlockListController;

+ class ContactSuggester;

+ class ContactsFromXMPPRoster;

+ class FdpFormSubmitController;

+

+ class AccountController {

+ public:

+ AccountController(

+ EventLoop* eventLoop,

+ NetworkFactories* networkFactories,

+ UIFactory* uiFactories,

+ SettingsProvider *settings,

+ SystemTray* systemTray,

+ SoundPlayer* soundPlayer,

+ StoragesFactory* storagesFactory,

+ CertificateStorageFactory* certificateStorageFactory,

+ Dock* dock,

+ Notifier* notifier,

+ URIHandler* uriHandler,

+ IdleDetector* idleDetector,

+ const std::map<std::string, std::string>& emoticons,

+ bool useDelayForLatency);

+ ~AccountController();

+

+ private:

+ void resetClient();

+ void handleConnected();

+ void handleLoginRequest(const std::string& username, const std::string& password, const std::string& certificatePath, CertificateWithKey::ref certificate, const ClientOptions& options, bool remember, bool loginAutomatically);

+ void handleCancelLoginRequest();

+ void handleQuitRequest();

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

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

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

+ void handleEventQueueLengthChange(size_t count);

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

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

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

+ void sendPresence(std::shared_ptr<Presence> presence);

+ void handleInputIdleChanged(bool);

+ void handleShowCertificateRequest();

+ void logout();

+ void signOut();

+ void setReconnectTimer();

+ void resetPendingReconnects();

+ void resetCurrentError();

+ void enableMessageCarbons();

+

+ void performLoginFromCachedCredentials();

+ void reconnectAfterError();

+ void setManagersOffline();

+ void handleNotificationClicked(const JID& jid);

+ void handleForceQuit();

+ void purgeCachedCredentials();

+ std::string serializeClientOptions(const ClientOptions& options);

+

+ private:

+ EventLoop* eventLoop_;

+ NetworkFactories* networkFactories_;

+ UIFactory* uiFactory_;

+ StoragesFactory* storagesFactory_;

+ Storages* storages_;

+ CertificateStorageFactory* certificateStorageFactory_;

+ CertificateStorage* certificateStorage_;

+ CertificateStorageTrustChecker* certificateTrustChecker_;

+ bool clientInitialized_;

+ std::shared_ptr<Client> client_;

+ SettingsProvider *settings_;

+ ProfileSettingsProvider* profileSettings_ = nullptr;

+ Dock* dock_;

+ URIHandler* uriHandler_;

+ IdleDetector* idleDetector_;

+ TogglableNotifier* notifier_;

+ PresenceNotifier* presenceNotifier_;

+ EventNotifier* eventNotifier_;

+ std::unique_ptr<Chattables> chattables_;

+ RosterController* rosterController_;

+ EventController* eventController_;

+ EventWindowController* eventWindowController_;

+ AdHocManager* adHocManager_;

+ LoginWindow* loginWindow_;

+ UIEventStream* uiEventStream_;

+ XMLConsoleController* xmlConsoleController_;

+ HistoryViewController* historyViewController_;

+ HistoryController* historyController_;

+ FileTransferListController* fileTransferListController_;

+ BlockListController* blockListController_;

+ ChatsManager* chatsManager_;

+ ProfileController* profileController_;

+ ShowProfileController* showProfileController_;

+ ContactEditController* contactEditController_;

+ ContactsFromXMPPRoster* contactsFromRosterProvider_;

+ ContactSuggester* contactSuggesterWithoutRoster_;

+ ContactSuggester* contactSuggesterWithRoster_;

+ JID jid_;

+ JID boundJID_;

+ SystemTrayController* systemTrayController_;

+ SoundEventController* soundEventController_;

+ XMPPURIController* xmppURIController_;

+ std::string vCardPhotoHash_;

+ std::string password_;

+ CertificateWithKey::ref certificate_;

+ ClientOptions clientOptions_;

+ std::shared_ptr<ErrorEvent> lastDisconnectError_;

+ bool useDelayForLatency_;

+ UserSearchController* userSearchControllerChat_;

+ UserSearchController* userSearchControllerAdd_;

+ UserSearchController* userSearchControllerInvite_;

+ int timeBeforeNextReconnect_;

+ Timer::ref reconnectTimer_;

+ StatusTracker* statusTracker_;

+ bool myStatusLooksOnline_ = false;

+ bool quitRequested_;

+ bool offlineRequested_;

+ static const int SecondsToWaitBeforeForceQuitting;

+ FileTransferOverview* ftOverview_;

+ WhiteboardManager* whiteboardManager_;

+ HighlightManager* highlightManager_;

+ HighlightEditorController* highlightEditorController_;

+ std::map<std::string, std::string> emoticons_;

+ boost::signals2::connection enableCarbonsRequestHandlerConnection_;

+ std::unique_ptr<FdpFormSubmitController> fdpFormSubmitController_;

+ };

+}

+/*

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/AdHocController.h>

+

+#include <boost/bind.hpp>

+

+#include <Swift/Controllers/UIInterfaces/AdHocCommandWindowFactory.h>

+

+namespace Swift {

+

+AdHocController::AdHocController(AdHocCommandWindowFactory* factory, std::shared_ptr<OutgoingAdHocCommandSession> command) {

+ window_ = factory->createAdHocCommandWindow(command);

+ window_->onClosing.connect(boost::bind(&AdHocController::handleWindowClosed, this));

+}

+

+AdHocController::~AdHocController() {

+ window_->onClosing.disconnect(boost::bind(&AdHocController::handleWindowClosed, this));

+ delete window_;

+}

+

+void AdHocController::setOnline(bool online) {

+ window_->setOnline(online);

+}

+

+void AdHocController::handleWindowClosed() {

+ onDeleting();

+}

+

+}

+/*

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

+

+namespace Swift {

+

+class AdHocCommandWindowFactory;

+class AdHocCommandWindow;

+

+class AdHocController {

+public:

+ AdHocController(AdHocCommandWindowFactory* factory, std::shared_ptr<OutgoingAdHocCommandSession> command);

+ ~AdHocController();

+ boost::signals2::signal<void ()> onDeleting;

+ void setOnline(bool online);

+private:

+ void handleWindowClosed();

+ AdHocCommandWindow* window_;

+};

+

+}

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <Swiften/Queries/IQRouter.h>

+

+#include <Swift/Controllers/UIEvents/RequestAdHocWithJIDUIEvent.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIInterfaces/AdHocCommandWindowFactory.h>

+#include <Swift/Controllers/UIInterfaces/MainWindow.h>

+ iqRouter_ = iqRouter;

+ uiEventStream_ = uiEventStream;

+ mainWindow_ = mainWindow;

+ factory_ = factory;

+ uiEventStream_->onUIEvent.connect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

+ uiEventStream_->onUIEvent.disconnect(boost::bind(&AdHocManager::handleUIEvent, this, _1));

+ for (auto& controller : controllers_) {

+ controller->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controller));

+ }

+void AdHocManager::removeController(std::shared_ptr<AdHocController> controller) {

+ controller->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.erase(std::find(controllers_.begin(), controllers_.end(), controller));

+}

+

+void AdHocManager::setServerDiscoInfo(std::shared_ptr<DiscoInfo> info) {

+ if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::CommandsFeature)) {

+ if (discoItemsRequest_) {

+ discoItemsRequest_->onResponse.disconnect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

+ discoItemsRequest_.reset();

+ }

+ discoItemsRequest_ = GetDiscoItemsRequest::create(JID(jid_.getDomain()), DiscoInfo::CommandsFeature, iqRouter_);

+ discoItemsRequest_->onResponse.connect(boost::bind(&AdHocManager::handleServerDiscoItemsResponse, this, _1, _2));

+ discoItemsRequest_->send();

+ } else {

+ mainWindow_->setAvailableAdHocCommands(std::vector<DiscoItems::Item>());

+ }

+}

+void AdHocManager::setOnline(bool online) {

+ for (auto&& controller : controllers_) {

+ controller->setOnline(online);

+ }

+void AdHocManager::handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems> items, ErrorPayload::ref error) {

+ std::vector<DiscoItems::Item> commands;

+ if (!error) {

+ for (const auto& item : items->getItems()) {

+ if (item.getNode() != "http://isode.com/xmpp/commands#test") {

+ commands.push_back(item);

+ }

+ }

+ }

+ mainWindow_->setAvailableAdHocCommands(commands);

+void AdHocManager::handleUIEvent(std::shared_ptr<UIEvent> event) {

+ std::shared_ptr<RequestAdHocUIEvent> adHocEvent = std::dynamic_pointer_cast<RequestAdHocUIEvent>(event);

+ if (adHocEvent) {

+ std::shared_ptr<OutgoingAdHocCommandSession> command = std::make_shared<OutgoingAdHocCommandSession>(adHocEvent->getCommand().getJID(), adHocEvent->getCommand().getNode(), iqRouter_);

+ std::shared_ptr<AdHocController> controller = std::make_shared<AdHocController>(factory_, command);

+ controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.push_back(controller);

+ }

+ std::shared_ptr<RequestAdHocWithJIDUIEvent> adHocJIDEvent = std::dynamic_pointer_cast<RequestAdHocWithJIDUIEvent>(event);

+ if (!!adHocJIDEvent) {

+ std::shared_ptr<OutgoingAdHocCommandSession> command = std::make_shared<OutgoingAdHocCommandSession>(adHocJIDEvent->getJID(), adHocJIDEvent->getNode(), iqRouter_);

+ std::shared_ptr<AdHocController> controller = std::make_shared<AdHocController>(factory_, command);

+ controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.push_back(controller);

+ }

+ * Copyright (c) 2010-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <boost/signals2.hpp>

+

+#include <Swiften/Disco/GetDiscoItemsRequest.h>

+#include <Swiften/JID/JID.h>

+

+#include <Swift/Controllers/AdHocController.h>

+class IQRouter;

+class MainWindow;

+class UIEventStream;

+class AdHocCommandWindowFactory;

+

+class AdHocManager {

+public:

+ AdHocManager(const JID& jid, AdHocCommandWindowFactory* factory, IQRouter* iqRouter, UIEventStream* uiEventStream, MainWindow* mainWindow);

+ ~AdHocManager();

+ void removeController(std::shared_ptr<AdHocController> contoller);

+ void setServerDiscoInfo(std::shared_ptr<DiscoInfo> info);

+ void setOnline(bool online);

+

+private:

+ void handleServerDiscoItemsResponse(std::shared_ptr<DiscoItems>, ErrorPayload::ref error);

+ void handleUIEvent(std::shared_ptr<UIEvent> event);

+ boost::signals2::signal<void (const AdHocController&)> onControllerComplete;

+

+private:

+ JID jid_;

+ IQRouter* iqRouter_;

+ UIEventStream* uiEventStream_;

+ MainWindow* mainWindow_;

+ AdHocCommandWindowFactory* factory_;

+ GetDiscoItemsRequest::ref discoItemsRequest_;

+ std::vector<std::shared_ptr<AdHocController> > controllers_;

+};

+

+ * Copyright (c) 2010 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+/*

+ * Copyright (c) 2014-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swiften/Base/format.h>

+#include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>

+#include <Swift/Controllers/XMPPEvents/ErrorEvent.h>

+BlockListController::BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController) : blockListManager_(blockListManager), blockListEditorWidgetFactory_(blockListEditorWidgetFactory), blockListEditorWidget_(nullptr), eventController_(eventController), remainingRequests_(0), uiEventStream_(uiEventStream) {

+ uiEventStream->onUIEvent.connect(boost::bind(&BlockListController::handleUIEvent, this, _1));

+ blockListManager_->getBlockList()->onItemAdded.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ uiEventStream_->onUIEvent.disconnect(boost::bind(&BlockListController::handleUIEvent, this, _1));

+ blockListManager_->getBlockList()->onItemAdded.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ for (const auto& jid : blockListBeforeEdit) {

+ if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

+ jidsToUnblock.push_back(jid);

+ }

+ }

+

+ for (const auto& jid : newBlockList) {

+ if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

+ jidsToBlock.push_back(jid);

+ }

+ }

+void BlockListController::handleUIEvent(std::shared_ptr<UIEvent> rawEvent) {

+ // handle UI dialog

+ std::shared_ptr<RequestBlockListDialogUIEvent> requestDialogEvent = std::dynamic_pointer_cast<RequestBlockListDialogUIEvent>(rawEvent);

+ if (requestDialogEvent != nullptr) {

+ if (blockListEditorWidget_ == nullptr) {

+ blockListEditorWidget_ = blockListEditorWidgetFactory_->createBlockListEditorWidget();

+ blockListEditorWidget_->onSetNewBlockList.connect(boost::bind(&BlockListController::handleSetNewBlockList, this, _1));

+ }

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ blockListEditorWidget_->setError("");

+ blockListEditorWidget_->show();

+ return;

+ }

+

+ // handle block state change

+ std::shared_ptr<RequestChangeBlockStateUIEvent> changeStateEvent = std::dynamic_pointer_cast<RequestChangeBlockStateUIEvent>(rawEvent);

+ if (changeStateEvent != nullptr) {

+ if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Blocked) {

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDRequest(changeStateEvent->getContact());

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ blockRequest->send();

+ } else if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Unblocked) {

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDRequest(changeStateEvent->getContact());

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ unblockRequest->send();

+ }

+ return;

+ }

+void BlockListController::handleBlockResponse(GenericRequest<BlockPayload>::ref request, std::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to block %1%.")) % jids.at(0).toString());

+ if (!error->getText().empty()) {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ if (blockListEditorWidget_ && originEditor) {

+ blockListEditorWidget_->setError(errorMessage);

+ blockListEditorWidget_->setBusy(false);

+ }

+ else {

+ eventController_->handleIncomingEvent(std::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0) && !error) {

+ blockListEditorWidget_->setBusy(false);

+ blockListEditorWidget_->hide();

+ }

+ }

+void BlockListController::handleUnblockResponse(GenericRequest<UnblockPayload>::ref request, std::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to unblock %1%.")) % jids.at(0).toString());

+ if (!error->getText().empty()) {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ if (blockListEditorWidget_ && originEditor) {

+ blockListEditorWidget_->setError(errorMessage);

+ blockListEditorWidget_->setBusy(false);

+ }

+ else {

+ eventController_->handleIncomingEvent(std::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0) && !error) {

+ blockListEditorWidget_->setBusy(false);

+ blockListEditorWidget_->hide();

+ }

+ }

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+

+ blockListDifferences(newBlockList, jidsToUnblock, jidsToBlock);

+

+ if (!jidsToBlock.empty()) {

+ remainingRequests_++;

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDsRequest(jidsToBlock);

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, jidsToBlock, true));

+ blockRequest->send();

+ }

+ if (!jidsToUnblock.empty()) {

+ remainingRequests_++;

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDsRequest(jidsToUnblock);

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, jidsToUnblock, true));

+ unblockRequest->send();

+ }

+ if (!jidsToBlock.empty() || !jidsToUnblock.empty()) {

+ assert(blockListEditorWidget_);

+ blockListEditorWidget_->setBusy(true);

+ blockListEditorWidget_->setError("");

+ } else {

+ blockListEditorWidget_->hide();

+ }

+ if (blockListEditorWidget_) {

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+ blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+ for (const auto& jid : jidsToBlock) {

+ if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

+ blockListBeforeEdit.push_back(jid);

+ }

+ }

+ for (const auto& jid : jidsToUnblock) {

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

+ }

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ }

+/*

+ * Copyright (c) 2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <memory>

+

+ BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController);

+ ~BlockListController();

+ void blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID>& jidsToUnblock, std::vector<JID>& jidsToBlock) const;

+ void handleUIEvent(std::shared_ptr<UIEvent> event);

+ void handleBlockResponse(GenericRequest<BlockPayload>::ref, std::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+ void handleUnblockResponse(GenericRequest<UnblockPayload>::ref, std::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+ void handleSetNewBlockList(const std::vector<JID>& newBlockList);

+ void handleBlockListChanged();

+ ClientBlockListManager* blockListManager_;

+ BlockListEditorWidgetFactory* blockListEditorWidgetFactory_;

+ BlockListEditorWidget* blockListEditorWidget_;

+ EventController* eventController_;

+ std::vector<JID> blockListBeforeEdit;

+ int remainingRequests_;

+ UIEventStream* uiEventStream_;

+ * Copyright (c) 2011-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <Swift/Controllers/Storages/CertificateStorageFactory.h>

+ class CertificateFactory;

+ class CertificateMemoryStorageFactory : public CertificateStorageFactory {

+ public:

+ CertificateMemoryStorageFactory() {

+ }

+ virtual CertificateStorage* createCertificateStorage(const JID&) const {

+ return new CertificateMemoryStorage();

+ }

+ private:

+ boost::filesystem::path basePath;

+ CertificateFactory* certificateFactory;

+ };

+/*

+ * Copyright (c) 2014-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swiften/Roster/XMPPRoster.h>

+

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+ class AutoAcceptMUCInviteDecider {

+ public:

+ AutoAcceptMUCInviteDecider(const JID& domain, XMPPRoster* roster, SettingsProvider* settings) : domain_(domain), roster_(roster), settings_(settings) {

+ }

+

+ bool isAutoAcceptedInvite(const JID& from, MUCInvitationPayload::ref invite) {

+ if (!invite->getIsImpromptu()) {

+ return false; /* always ask the user for normal MUC invites */

+ }

+

+ if (invite->getIsContinuation()) {

+ return true;

+ }

+

+ std::string auto_accept_mode = settings_->getSetting(SettingConstants::INVITE_AUTO_ACCEPT_MODE);

+ if (auto_accept_mode == "no") {

+ return false;

+ } else if (auto_accept_mode == "presence") {

+ return roster_->getSubscriptionStateForJID(from) == RosterItemPayload::From || roster_->getSubscriptionStateForJID(from) == RosterItemPayload::Both;

+ } else if (auto_accept_mode == "domain") {

+ return roster_->getSubscriptionStateForJID(from) == RosterItemPayload::From || roster_->getSubscriptionStateForJID(from) == RosterItemPayload::Both || from.getDomain() == domain_;

+ } else {

+ assert(false);

+ return false;

+ }

+ }

+

+ private:

+ JID domain_;

+ XMPPRoster* roster_;

+ SettingsProvider* settings_;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/Log.h>

+#include <Swiften/Base/Path.h>

+#include <Swiften/Base/format.h>

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/StanzaChannel.h>

+#include <Swiften/Disco/FeatureOracle.h>

+#include <Swiften/FileTransfer/FileTransferManager.h>

+#include <Swiften/Network/TimerFactory.h>

+#include <Swift/Controllers/Chat/ChatMessageParser.h>

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+#include <Swift/Controllers/Intl.h>

+#include <Swift/Controllers/SettingConstants.h>

+#include <Swift/Controllers/Translator.h>

+#include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>

+#include <Swift/Controllers/UIEvents/SendFileUIEvent.h>

+#include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>

+

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {

+ isInMUC_ = isInMUC;

+ lastWasPresence_ = false;

+ chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider, timerFactory, 20000);

+ chatStateTracker_ = new ChatStateTracker();

+ nickResolver_ = nickResolver;

+ presenceOracle_->onPresenceChange.connect(boost::bind(&ChatController::handlePresenceChange, this, _1));

+ chatStateTracker_->onChatStateChange.connect(boost::bind(&ChatWindow::setContactChatState, chatWindow_, _1));

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

+ nickResolver_->onNickChanged.connect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));

+ std::string nick = nickResolver_->jidToNick(toJID_);

+ chatWindow_->setName(nick);

+ std::string startMessage;

+ Presence::ref theirPresence;

+ if (isInMUC) {

+ startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());

+ theirPresence = presenceOracle->getLastPresence(contact);

+ } else {

+ startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());

+ theirPresence = contact.isBare() ? presenceOracle->getAccountPresence(contact) : presenceOracle->getLastPresence(contact);

+ }

+ Idle::ref idle;

+ if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {

+ startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(idle->getSince()));

+ }

+ startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);

+ if (theirPresence && !theirPresence->getStatus().empty()) {

+ startMessage += " (" + theirPresence->getStatus() + ")";

+ }

+ lastShownStatus_ = theirPresence ? theirPresence->getShow() : StatusShow::None;

+ chatStateNotifier_->setContactIsOnline(theirPresence && theirPresence->getType() == Presence::Available);

+ startMessage += ".";

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection);

+ continuationsBrokenConnection_ = chatWindow_->onContinuationsBroken.connect([this, startMessage]() { chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection); });

+ chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

+ chatWindow_->onFileTransferStart.connect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onFileTransferAccept.connect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferCancel.connect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onSendFileRequest.connect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+ chatWindow_->onWhiteboardSessionAccept.connect(boost::bind(&ChatController::handleWhiteboardSessionAccept, this));

+ chatWindow_->onWhiteboardSessionCancel.connect(boost::bind(&ChatController::handleWhiteboardSessionCancel, this));

+ chatWindow_->onWhiteboardWindowShow.connect(boost::bind(&ChatController::handleWhiteboardWindowShow, this));

+ chatWindow_->onBlockUserRequest.connect(boost::bind(&ChatController::handleBlockUserRequest, this));

+ chatWindow_->onUnblockUserRequest.connect(boost::bind(&ChatController::handleUnblockUserRequest, this));

+ chatWindow_->onInviteToChat.connect(boost::bind(&ChatController::handleInviteToChat, this, _1));

+ chatWindow_->onClosed.connect(boost::bind(&ChatController::handleWindowClosed, this));

+ ChatController::handleBareJIDCapsChanged(toJID_);

+

+ settings_->onSettingChanged.connect(boost::bind(&ChatController::handleSettingChanged, this, _1));

+ eventStream_->onUIEvent.connect(boost::bind(&ChatController::handleUIEvent, this, _1));

+ if (jid.toBare() == toJID_.toBare()) {

+ chatWindow_->setName(nickResolver_->jidToNick(toJID_));

+ }

+ eventStream_->onUIEvent.disconnect(boost::bind(&ChatController::handleUIEvent, this, _1));

+ settings_->onSettingChanged.disconnect(boost::bind(&ChatController::handleSettingChanged, this, _1));

+ nickResolver_->onNickChanged.disconnect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));

+ delete chatStateNotifier_;

+ delete chatStateTracker_;

+ return isInMUC_ ? toJID_ : ChatControllerBase::getBaseJID();

+ lastWasPresence_ = false;

+ FeatureOracle featureOracle(entityCapsProvider_, presenceOracle_);

+

+ chatWindow_->setCorrectionEnabled(featureOracle.isMessageCorrectionSupported(toJID_));

+ chatWindow_->setFileTransferEnabled(isInMUC_ ? No : featureOracle.isFileTransferSupported(toJID_));

+ contactSupportsReceipts_ = featureOracle.isMessageReceiptsSupported(toJID_);

+

+ checkForDisplayingDisplayReceiptsAlert();

+ chatStateNotifier_->setContact(jid);

+ ChatControllerBase::setToJID(jid);

+ Presence::ref presence;

+ if (isInMUC_) {

+ presence = presenceOracle_->getLastPresence(jid);

+ } else {

+ presence = jid.isBare() ? presenceOracle_->getAccountPresence(jid.toBare()) : presenceOracle_->getLastPresence(jid);

+ }

+ chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

+ handleBareJIDCapsChanged(toJID_);

+}

+

+void ChatController::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {

+ ChatControllerBase::setAvailableServerFeatures(info);

+ if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

+ std::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+

+ blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+ blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+ blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+

+ handleBlockingStateChanged();

+ }

+}

+

+bool ChatController::isIncomingMessageFromMe(std::shared_ptr<Message>) {

+ return false;

+}

+

+void ChatController::preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

+ if (messageEvent->isReadable()) {

+ chatWindow_->flash();

+ lastWasPresence_ = false;

+ }

+ std::shared_ptr<Message> message = messageEvent->getStanza();

+ JID from = message->getFrom();

+ if (!from.equals(toJID_, JID::WithResource)) {

+ if (toJID_.equals(from, JID::WithoutResource) && toJID_.isBare()){

+ // Bind controller to a full JID if message contains body text or is a typing chat state.

+ ChatState::ref chatState = message->getPayload<ChatState>();

+ if (!message->getBody().get_value_or("").empty() || (chatState && chatState->getChatState() == ChatState::Composing)) {

+ setToJID(from);

+ }

+ }

+ }

+ chatStateTracker_->handleMessageReceived(message);

+ chatStateNotifier_->receivedMessageFromContact(!!message->getPayload<ChatState>());

+

+ // handle XEP-0184 Message Receipts

+ // incomming receipts

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

+ SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID();

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

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

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

+ }

+ // incomming errors in response to send out receipts

+ } else if (message->getPayload<DeliveryReceiptRequest>() && (message->getType() == Message::Error)) {

+ if (requestedReceipts_.find(message->getID()) != requestedReceipts_.end()) {

+ chatWindow_->setMessageReceiptState(requestedReceipts_[message->getID()], ChatWindow::ReceiptFailed);

+ requestedReceipts_.erase(message->getID());

+ }

+ // incoming receipt requests

+ } else if (message->getPayload<DeliveryReceiptRequest>()) {

+ if (receivingPresenceFromUs_) {

+ std::shared_ptr<Message> receiptMessage = std::make_shared<Message>();

+ receiptMessage->setTo(toJID_);

+ receiptMessage->addPayload(std::make_shared<DeliveryReceipt>(message->getID()));

+ stanzaChannel_->sendMessage(receiptMessage);

+ }

+ }

+}

+

+void ChatController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ eventController_->handleIncomingEvent(messageEvent);

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleSoundNotifications(chatMessage);

+ }

+}

+

+

+void ChatController::preSendMessageRequest(std::shared_ptr<Message> message) {

+ chatStateNotifier_->addChatStateRequest(message);

+ if (userWantsReceipts_ && (contactSupportsReceipts_ != No) && message) {

+ message->addPayload(std::make_shared<DeliveryReceiptRequest>());

+ }

+ receivingPresenceFromUs_ = isReceivingPresence;

+ if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+ checkForDisplayingDisplayReceiptsAlert();

+ }

+ boost::optional<ChatWindow::AlertID> newDeliverReceiptAlert;

+ if (userWantsReceipts_ && (contactSupportsReceipts_ == No)) {

+ newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));

+ } else if (userWantsReceipts_ && (contactSupportsReceipts_ == Maybe)) {

+ newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you send."));

+ } else {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ deliveryReceiptAlert_.reset();

+ }

+ }

+ if (newDeliverReceiptAlert) {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ }

+ deliveryReceiptAlert_ = newDeliverReceiptAlert;

+ }

+ std::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+ if (blockList->getState() == BlockList::Available) {

+ if (isInMUC_ ? blockList->isBlocked(toJID_) : blockList->isBlocked(toJID_.toBare())) {

+ if (!blockedContactAlert_) {

+ blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));

+ }

+ chatWindow_->setBlockingState(ChatWindow::IsBlocked);

+

+ // disconnect typing events to prevent chat state notifciations to blocked contacts

+ chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

+ } else {

+ if (blockedContactAlert_) {

+ chatWindow_->removeAlert(*blockedContactAlert_);

+ blockedContactAlert_.reset();

+ }

+ chatWindow_->setBlockingState(ChatWindow::IsUnblocked);

+

+ chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

+ }

+ }

+ if (isInMUC_) {

+ eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));

+ } else {

+ eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_.toBare()));

+ }

+ if (isInMUC_) {

+ eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_));

+ } else {

+ eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));

+ }

+ std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(getToJID(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));

+ eventStream_->send(event);

+void ChatController::handleWindowClosed() {

+ onWindowClosed();

+void ChatController::handleUIEvent(std::shared_ptr<UIEvent> event) {

+ std::shared_ptr<InviteToMUCUIEvent> inviteEvent = std::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

+ if (inviteEvent && inviteEvent->getOriginator() == getToJID()) {

+ onConvertToMUC(detachChatWindow(), inviteEvent->getInvites(), inviteEvent->getReason());

+ }

+}

+void ChatController::handleIncomingOwnMessage(std::shared_ptr<Message> message) {

+ if (!message->getBody().get_value_or("").empty()) {

+ postSendMessage(message->getBody().get_value_or(""), message);

+ handleStanzaAcked(message);

+ onActivity(message->getBody().get_value_or(""));

+ }

+}

+void ChatController::postSendMessage(const std::string& body, std::shared_ptr<Stanza> sentStanza) {

+ std::shared_ptr<Replace> replace = sentStanza->getPayload<Replace>();

+ if (replace) {

+ eraseIf(unackedStanzas_, PairSecondEquals<std::shared_ptr<Stanza>, std::string>(myLastMessageUIID_));

+ replaceMessage(chatMessageParser_->parseMessageBody(body, "", true), myLastMessageUIID_, boost::posix_time::microsec_clock::universal_time());

+ } else {

+ myLastMessageUIID_ = addMessage(chatMessageParser_->parseMessageBody(body, "", true), QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : std::shared_ptr<SecurityLabel>(), avatarManager_->getAvatarPath(selfJID_), boost::posix_time::microsec_clock::universal_time());

+ }

+ if (stanzaChannel_->getStreamManagementEnabled() && !myLastMessageUIID_.empty() ) {

+ chatWindow_->setAckState(myLastMessageUIID_, ChatWindow::Pending);

+ unackedStanzas_[sentStanza] = myLastMessageUIID_;

+ }

+ if (sentStanza->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[sentStanza->getID()] = myLastMessageUIID_;

+ chatWindow_->setMessageReceiptState(myLastMessageUIID_, ChatWindow::ReceiptRequested);

+ }

+

+ lastWasPresence_ = false;

+ chatStateNotifier_->userSentMessage();

+void ChatController::handleStanzaAcked(std::shared_ptr<Stanza> stanza) {

+ std::map<std::shared_ptr<Stanza>, std::string>::iterator unackedStanza = unackedStanzas_.find(stanza);

+ if (unackedStanza != unackedStanzas_.end()) {

+ chatWindow_->setAckState(unackedStanza->second, ChatWindow::Received);

+ unackedStanzas_.erase(unackedStanza);

+ }

+ if (!online) {

+ for (auto& stanzaIdPair : unackedStanzas_) {

+ chatWindow_->setAckState(stanzaIdPair.second, ChatWindow::Failed);

+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+ }

+ unackedStanzas_.clear();

+ Presence::ref fakeOffline(new Presence());

+ fakeOffline->setFrom(toJID_);

+ fakeOffline->setType(Presence::Unavailable);

+ chatStateTracker_->handlePresenceChange(fakeOffline);

+ }

+ ChatControllerBase::setOnline(online);

+ std::string nick = senderDisplayNameFromMessage(ftc->getOtherParty());

+ std::string avatarPath;

+ if (ftc->isIncoming()) {

+ avatarPath = pathToString(avatarManager_->getAvatarPath(ftc->getOtherParty()));

+ }

+ else {

+ avatarPath = pathToString(avatarManager_->getAvatarPath(selfJID_));

+ }

+

+ std::string ftID = ftc->setChatWindow(chatWindow_, nick, avatarPath);

+ ftControllers[ftID] = ftc;

+ lastWasPresence_ = false;

+

+ if (ftc->isIncoming()) {

+ auto incomingFileTransferEvent = std::make_shared<IncomingFileTransferEvent>(ftc->getOtherParty());

+ if (hasOpenWindow()) {

+ incomingFileTransferEvent->conclude();

+ }

+ else {

+ unreadMessages_.push_back(incomingFileTransferEvent);

+ updateMessageCount();

+ }

+ eventController_->handleIncomingEvent(incomingFileTransferEvent);

+ }

+ lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

+ chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

+ SWIFT_LOG(debug) << "handleFileTransferCancel(" << id << ")";

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

+ ftControllers[id]->cancel();

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+ SWIFT_LOG(debug) << "handleFileTransferStart(" << id << ", " << description << ")";

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

+ ftControllers[id]->start(description);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+ SWIFT_LOG(debug) << "handleFileTransferAccept(" << id << ", " << filename << ")";

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

+ ftControllers[id]->accept(filename);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+ SWIFT_LOG(debug) << "ChatController::handleSendFileRequest(" << filename << ")";

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

+ eventStream_->send(std::make_shared<AcceptWhiteboardSessionUIEvent>(toJID_));

+ eventStream_->send(std::make_shared<CancelWhiteboardSessionUIEvent>(toJID_));

+ eventStream_->send(std::make_shared<ShowWhiteboardUIEvent>(toJID_));

+}

+

+std::string ChatController::senderHighlightNameFromMessage(const JID& from) {

+ if (isInMUC_) {

+ return nickResolver_->jidToNick(from);

+ }

+ else {

+ return from.toBare().toString();

+ }

+ return nickResolver_->jidToNick(from);

+}

+

+std::string ChatController::getStatusChangeString(std::shared_ptr<Presence> presence) {

+ std::string nick = senderDisplayNameFromMessage(presence->getFrom());

+ std::string response;

+ if (!presence || presence->getType() == Presence::Unavailable || presence->getType() == Presence::Error) {

+ response = QT_TRANSLATE_NOOP("", "%1% has gone offline");

+ } else if (presence->getType() == Presence::Available) {

+ StatusShow::Type show = presence->getShow();

+ if (show == StatusShow::Online || show == StatusShow::FFC) {

+ response = QT_TRANSLATE_NOOP("", "%1% has become available");

+ } else if (show == StatusShow::Away || show == StatusShow::XA) {

+ response = QT_TRANSLATE_NOOP("", "%1% has gone away");

+ } else if (show == StatusShow::DND) {

+ response = QT_TRANSLATE_NOOP("", "%1% is now busy");

+ }

+ }

+ Idle::ref idle;

+ if ((idle = presence->getPayload<Idle>())) {

+ response += str(format(QT_TRANSLATE_NOOP("", " and has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(idle->getSince()));

+ }

+

+ if (!response.empty()) {

+ response = str(format(response) % nick);

+ }

+

+ if (!presence->getStatus().empty()) {

+ response += " (" + presence->getStatus() + ")";

+ }

+ return response + ".";

+}

+

+void ChatController::handlePresenceChange(std::shared_ptr<Presence> newPresence) {

+ bool relevantPresence = false;

+

+ if (isInMUC_) {

+ // For MUC participants we only have a single presence to choose one and

+ // even for multi-session nicknames multiple resources are not distinguishable

+ // to other participants.

+ if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {

+ relevantPresence = true;

+ }

+ }

+ else {

+ // For standard chats we retrieve the account presence from the PresenceOracle,

+ // as there can be multiple presences to choose from.

+ if (toJID_.equals(newPresence->getFrom(), JID::WithoutResource)) {

+ // Presence matches ChatController JID.

+ newPresence = presenceOracle_->getAccountPresence(toJID_);

+ relevantPresence = true;

+ }

+ }

+

+ if (!relevantPresence) {

+ return;

+ }

+

+ if (!newPresence) {

+ newPresence = std::make_shared<Presence>();

+ newPresence->setType(Presence::Unavailable);

+ }

+ lastShownStatus_ = newPresence->getShow();

+

+ chatStateTracker_->handlePresenceChange(newPresence);

+ chatStateNotifier_->setContactIsOnline(newPresence->getType() == Presence::Available);

+ std::string newStatusChangeString = getStatusChangeString(newPresence);

+ if (newStatusChangeString != lastStatusChangeString_) {

+ if (lastWasPresence_) {

+ chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::UpdateTimestamp);

+ } else {

+ chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::DefaultDirection);

+ }

+ lastStatusChangeString_ = newStatusChangeString;

+ lastWasPresence_ = true;

+ }

+}

+

+boost::optional<boost::posix_time::ptime> ChatController::getMessageTimestamp(std::shared_ptr<Message> message) const {

+ return message->getTimestamp();

+}

+

+void ChatController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {

+ lastMessagesIDs_[from.toBare()] = {messageID, addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), timeStamp)};

+}

+

+void ChatController::handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {

+ auto lastMessage = lastMessagesIDs_.find(from.toBare());

+ if ((lastMessage != lastMessagesIDs_.end()) && (lastMessage->second.idInStream == idToReplace)) {

+ replaceMessage(message, lastMessage->second.idInWindow, timeStamp);

+ }

+ else {

+ addMessageHandleIncomingMessage(from, message, messageID, senderIsSelf, label, timeStamp);

+ }

+ HistoryMessage::Type type;

+ if (mucRegistry_->isMUC(fromJID.toBare()) || mucRegistry_->isMUC(toJID.toBare())) {

+ type = HistoryMessage::PrivateMessage;

+ }

+ else {

+ type = HistoryMessage::Chat;

+ }

+

+ if (historyController_) {

+ historyController_->addMessage(message, fromJID, toJID, type, timeStamp);

+ }

+}

+

+bool ChatController::shouldIgnoreMessage(std::shared_ptr<Message> message) {

+ if (!message->getID().empty()) {

+ if (message->getID() == lastHandledMessageID_) {

+ return true;

+ }

+ else {

+ lastHandledMessageID_ = message->getID();

+ }

+ }

+ return false;

+}

+JID ChatController::messageCorrectionJID(const JID& fromJID) {

+ return fromJID.toBare();

+ continuationsBrokenConnection_.disconnect();

+ chatWindow_->onClosed.disconnect(boost::bind(&ChatController::handleWindowClosed, this));

+ chatWindow_->onInviteToChat.disconnect(boost::bind(&ChatController::handleInviteToChat, this, _1));

+ chatWindow_->onUnblockUserRequest.disconnect(boost::bind(&ChatController::handleUnblockUserRequest, this));

+ chatWindow_->onBlockUserRequest.disconnect(boost::bind(&ChatController::handleBlockUserRequest, this));

+ chatWindow_->onWhiteboardWindowShow.disconnect(boost::bind(&ChatController::handleWhiteboardWindowShow, this));

+ chatWindow_->onWhiteboardSessionCancel.disconnect(boost::bind(&ChatController::handleWhiteboardSessionCancel, this));

+ chatWindow_->onWhiteboardSessionAccept.disconnect(boost::bind(&ChatController::handleWhiteboardSessionAccept, this));

+ chatWindow_->onSendFileRequest.disconnect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+ chatWindow_->onFileTransferCancel.disconnect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onFileTransferAccept.disconnect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferStart.disconnect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

+ chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ return ChatControllerBase::detachChatWindow();

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <Swiften/Base/Tristate.h>

+

+#include <Swift/Controllers/Chat/ChatControllerBase.h>

+ class AvatarManager;

+ class ChatStateNotifier;

+ class ChatStateTracker;

+ class ClientBlockListManager;

+ class EntityCapsProvider;

+ class FileTransferController;

+ class HighlightManager;

+ class HistoryController;

+ class NickResolver;

+ class SettingsProvider;

+ class TimerFactory;

+ class UIEvent;

+

+ class ChatController : public ChatControllerBase {

+ public:

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;

+ virtual void setOnline(bool online) override;

+ virtual void handleNewFileTransferController(FileTransferController* ftc);

+ virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

+ virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;

+

+ protected:

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+

+ private:

+ void handlePresenceChange(std::shared_ptr<Presence> newPresence);

+ std::string getStatusChangeString(std::shared_ptr<Presence> presence);

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const override;

+ void handleStanzaAcked(std::shared_ptr<Stanza> stanza);

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+

+ void handleFileTransferCancel(std::string /* id */);

+ void handleFileTransferStart(std::string /* id */, std::string /* description */);

+ void handleFileTransferAccept(std::string /* id */, std::string /* filename */);

+ void handleSendFileRequest(std::string filename);

+

+ void handleWhiteboardSessionAccept();

+ void handleWhiteboardSessionCancel();

+ void handleWhiteboardWindowShow();

+

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

+ void checkForDisplayingDisplayReceiptsAlert();

+

+ void handleBlockingStateChanged();

+ void handleBlockUserRequest();

+ void handleUnblockUserRequest();

+

+ void handleInviteToChat(const std::vector<JID>& droppedJIDs);

+

+ void handleWindowClosed();

+

+ void handleUIEvent(std::shared_ptr<UIEvent> event);

+

+ private:

+ NickResolver* nickResolver_;

+ ChatStateNotifier* chatStateNotifier_;

+ ChatStateTracker* chatStateTracker_;

+ std::string myLastMessageUIID_;

+ bool isInMUC_;

+ std::string lastStatusChangeString_;

+ StatusShow::Type lastShownStatus_;

+

+ Tristate contactSupportsReceipts_;

+ bool receivingPresenceFromUs_ = false;

+ bool userWantsReceipts_;

+ std::map<std::string, FileTransferController*> ftControllers;

+ std::string lastWbID_;

+ std::string lastHandledMessageID_;

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::signals2::scoped_connection blockingOnStateChangedConnection_;

+ boost::signals2::scoped_connection blockingOnItemAddedConnection_;

+ boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

+ boost::signals2::scoped_connection continuationsBrokenConnection_;

+

+ boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;

+ boost::optional<ChatWindow::AlertID> blockedContactAlert_;

+ };

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <sstream>

+#include <boost/algorithm/string.hpp>

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swiften/Base/format.h>

+#include <Swiften/Disco/EntityCapsProvider.h>

+#include <Swiften/Elements/DeliveryReceipt.h>

+#include <Swiften/Elements/DeliveryReceiptRequest.h>

+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

+#include <Swift/Controllers/Chat/Chattables.h>

+#include <Swift/Controllers/Chat/ChatMessageParser.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings), chattables_(chattables) {

+ chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

+ chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

+ chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ chatWindow_->onContinuationsBroken.connect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

+ highlighter_ = highlightManager->createHighlighter(nickResolver);

+ ChatControllerBase::setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

+ delete highlighter_;

+ delete chatWindow_;

+void ChatControllerBase::handleContinuationsBroken() {

+ cancelReplaces();

+ chatWindow_->onContinuationsBroken.disconnect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));

+ chatWindow_->onSendMessageRequest.disconnect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ chatWindow_->onAllMessagesRead.disconnect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

+ scopedConnectionResendMessage_.disconnect();

+ ChatWindow* chatWindow = chatWindow_;

+ chatWindow_ = nullptr;

+ return chatWindow;

+ if (jid.compare(toJID_, JID::WithoutResource) == 0) {

+ handleBareJIDCapsChanged(jid);

+ }

+ if (chatWindow_) {

+ chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

+ }

+ chatWindow_->setOnline(enabled);

+ chatWindow_->setCanInitiateImpromptuChats(false);

+ setEnabled(online);

+ return JID(toJID_.toBare());

+void ChatControllerBase::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {

+ if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::SecurityLabelsCatalogFeature)) {

+ GetSecurityLabelsCatalogRequest::ref request = GetSecurityLabelsCatalogRequest::create(getBaseJID(), iqRouter_);

+ request->onResponse.connect(boost::bind(&ChatControllerBase::handleSecurityLabelsCatalogResponse, this, _1, _2));

+ request->send();

+ } else {

+ chatWindow_->setSecurityLabelsEnabled(false);

+ labelsEnabled_ = false;

+ }

+ if (!unreadMessages_.empty()) {

+ targetedUnreadMessages_.clear();

+ for (std::shared_ptr<StanzaEvent> stanzaEvent : unreadMessages_) {

+ stanzaEvent->conclude();

+ }

+ unreadMessages_.clear();

+ updateMessageCount();

+ }

+size_t ChatControllerBase::getUnreadCount() {

+ return targetedUnreadMessages_.size();

+ if (!stanzaChannel_->isAvailable() || body.empty()) {

+ return;

+ }

+ std::shared_ptr<Message> message(new Message());

+ message->setTo(toJID_);

+ message->setType(Swift::Message::Chat);

+ message->setBody(body);

+ if (labelsEnabled_) {

+ if (!isCorrectionMessage) {

+ lastLabel_ = chatWindow_->getSelectedSecurityLabel();

+ }

+ SecurityLabelsCatalog::Item labelItem = lastLabel_;

+ if (labelItem.getLabel()) {

+ message->addPayload(labelItem.getLabel());

+ }

+ }

+ preSendMessageRequest(message);

+

+ boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

+ if (useDelayForLatency_) {

+ message->addPayload(std::make_shared<Delay>(now, selfJID_));

+ }

+ if (isCorrectionMessage) {

+ message->addPayload(std::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

+ }

+ message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

+ stanzaChannel_->sendMessage(message);

+ postSendMessage(message->getBody().get(), std::dynamic_pointer_cast<Stanza>(message));

+ onActivity(message->getBody().get());

+ logMessage(body, selfJID_, toJID_, now, false);

+void ChatControllerBase::handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

+ if (catalog && !error) {

+ if (catalog->getItems().size() == 0) {

+ chatWindow_->setSecurityLabelsEnabled(false);

+ labelsEnabled_ = false;

+ } else {

+ labelsEnabled_ = true;

+ chatWindow_->setAvailableSecurityLabels(catalog->getItems());

+ chatWindow_->setSecurityLabelsEnabled(true);

+ }

+ } else {

+ labelsEnabled_ = false;

+ chatWindow_->setSecurityLabelsError();

+ }

+ chatWindow_->show();

+ chatWindow_->activate();

+}

+

+bool ChatControllerBase::hasOpenWindow() const {

+ return chatWindow_ && chatWindow_->isVisible();

+}

+

+ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {

+ ChatWindow::ChatMessage chatMessage;

+ chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);

+ return chatMessage;

+void ChatControllerBase::updateMessageCount() {

+ auto baseJID = getBaseJID();

+ auto state = chattables_.getState(baseJID);

+ state.unreadCount = unreadMessages_.size();

+ chatWindow_->setUnreadMessageCount(state.unreadCount);

+ chattables_.setState(baseJID, state);

+#ifndef NOT_YET

+ onUnreadCountChanged();

+#endif

+}

+

+std::string ChatControllerBase::addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time) {

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

+ if (chatMessage.isMeCommand()) {

+ return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ }

+ else {

+ return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ }

+void ChatControllerBase::replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time) {

+ if (chatMessage.isMeCommand()) {

+ chatWindow_->replaceWithAction(chatMessage, id, time);

+ }

+ else {

+ chatWindow_->replaceMessage(chatMessage, id, time);

+ }

+ return from.toBare() == toJID_.toBare();

+void ChatControllerBase::handleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

+ std::shared_ptr<Message> message = messageEvent->getStanza();

+ if (shouldIgnoreMessage(message)) {

+ return;

+ }

+

+ preHandleIncomingMessage(messageEvent);

+ if (messageEvent->isReadable() && !messageEvent->getConcluded()) {

+ unreadMessages_.push_back(messageEvent);

+ if (messageEvent->targetsMe()) {

+ targetedUnreadMessages_.push_back(messageEvent);

+ }

+ }

+

+ ChatWindow::ChatMessage chatMessage;

+ boost::optional<std::string> optionalBody = message->getBody();

+ std::string body = optionalBody.get_value_or("");

+ if (message->isError()) {

+ if (!message->getTo().getResource().empty()) {

+ std::string errorMessage;

+ if (message->getPayload<Swift::ErrorPayload>()->getCondition() == ErrorPayload::ItemNotFound) {

+ errorMessage = QT_TRANSLATE_NOOP("", "This user could not be found in the room.");

+ }

+ else {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

+ }

+ chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

+ }

+ }

+ else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {

+ handleMUCInvitation(messageEvent->getStanza());

+ return;

+ }

+ else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {

+ handleMediatedMUCInvitation(messageEvent->getStanza());

+ return;

+ }

+ else {

+ if (!messageEvent->isReadable()) {

+ return;

+ }

+ showChatWindow();

+ JID from = message->getFrom();

+ std::vector<std::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

+ for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

+ if (!delayPayloads[i]->getFrom()) {

+ continue;

+ }

+ boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

+ std::ostringstream s;

+ s << "The following message took " << (now - delayPayloads[i]->getStamp()).total_milliseconds() / 1000.0 << " seconds to be delivered from " << delayPayloads[i]->getFrom()->toString() << ".";

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);

+ }

+ std::shared_ptr<SecurityLabel> label = message->getPayload<SecurityLabel>();

+

+ // Determine the timestamp

+ boost::posix_time::ptime timeStamp = boost::posix_time::microsec_clock::universal_time();

+ boost::optional<boost::posix_time::ptime> messageTimeStamp = getMessageTimestamp(message);

+ if (messageTimeStamp) {

+ timeStamp = *messageTimeStamp;

+ }

+ onActivity(body);

+

+ std::shared_ptr<Replace> replace = message->getPayload<Replace>();

+ bool senderIsSelf = isIncomingMessageFromMe(message);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ if (replace) {

+ handleIncomingReplaceMessage(from, chatMessage, message->getID(), replace->getID(), senderIsSelf, label, timeStamp);

+ }

+ else {

+ addMessageHandleIncomingMessage(from, chatMessage, message->getID(), senderIsSelf, label, timeStamp);

+ }

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ logMessage(body, from, selfJID_, timeStamp, true);

+#endif

+ }

+ chatWindow_->show();

+ updateMessageCount();

+ postHandleIncomingMessage(messageEvent, chatMessage);

+std::string ChatControllerBase::getErrorMessage(std::shared_ptr<ErrorPayload> error) {

+ std::string defaultMessage = QT_TRANSLATE_NOOP("", "Error sending message");

+ if (!error->getText().empty()) {

+ return error->getText();

+ }

+ else {

+ switch (error->getCondition()) {

+ case ErrorPayload::BadRequest: return QT_TRANSLATE_NOOP("", "Bad request");

+ case ErrorPayload::Conflict: return QT_TRANSLATE_NOOP("", "Conflict");

+ case ErrorPayload::FeatureNotImplemented: return QT_TRANSLATE_NOOP("", "This feature is not implemented");

+ case ErrorPayload::Forbidden: return QT_TRANSLATE_NOOP("", "Forbidden");

+ case ErrorPayload::Gone: return QT_TRANSLATE_NOOP("", "Recipient can no longer be contacted");

+ case ErrorPayload::InternalServerError: return QT_TRANSLATE_NOOP("", "Internal server error");

+ case ErrorPayload::ItemNotFound: return QT_TRANSLATE_NOOP("", "Item not found");

+ case ErrorPayload::JIDMalformed: return QT_TRANSLATE_NOOP("", "JID Malformed");

+ case ErrorPayload::NotAcceptable: return QT_TRANSLATE_NOOP("", "Message was rejected");

+ case ErrorPayload::NotAllowed: return QT_TRANSLATE_NOOP("", "Not allowed");

+ case ErrorPayload::NotAuthorized: return QT_TRANSLATE_NOOP("", "Not authorized");

+ case ErrorPayload::PaymentRequired: return QT_TRANSLATE_NOOP("", "Payment is required");

+ case ErrorPayload::RecipientUnavailable: return QT_TRANSLATE_NOOP("", "Recipient is unavailable");

+ case ErrorPayload::Redirect: return QT_TRANSLATE_NOOP("", "Redirect");

+ case ErrorPayload::RegistrationRequired: return QT_TRANSLATE_NOOP("", "Registration required");

+ case ErrorPayload::RemoteServerNotFound: return QT_TRANSLATE_NOOP("", "Recipient's server not found");

+ case ErrorPayload::RemoteServerTimeout: return QT_TRANSLATE_NOOP("", "Remote server timeout");

+ case ErrorPayload::ResourceConstraint: return QT_TRANSLATE_NOOP("", "The server is low on resources");

+ case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable");

+ case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required");

+ case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition");

+ case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request");

+ }

+ }

+ assert(false);

+ return defaultMessage;

+ unreadMessages_.push_back(event);

+ chatWindow_->show();

+ updateMessageCount();

+ chatWindow_->addMUCInvitation(senderDisplayNameFromMessage(event->getInviter()), event->getRoomJID(), event->getReason(), event->getPassword(), event->getDirect(), event->getImpromptu());

+ eventController_->handleIncomingEvent(event);

+ lastWasPresence_ = false;

+ MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

+

+ if (autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

+ eventStream_->send(std::make_shared<JoinMUCUIEvent>(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, true));

+ } else {

+ MUCInviteEvent::ref inviteEvent = std::make_shared<MUCInviteEvent>(toJID_, invite->getJID(), invite->getReason(), invite->getPassword(), true, invite->getIsImpromptu());

+ handleGeneralMUCInvitation(inviteEvent);

+ }

+ MUCUserPayload::Invite invite = *message->getPayload<MUCUserPayload>()->getInvite();

+ JID from = message->getFrom();

+ std::string reason;

+ if (!invite.reason.empty()) {

+ reason = invite.reason;

+ }

+ std::string password;

+ if (message->getPayload<MUCUserPayload>()->getPassword()) {

+ password = *message->getPayload<MUCUserPayload>()->getPassword();

+ }

+

+ MUCInviteEvent::ref inviteEvent = std::make_shared<MUCInviteEvent>(invite.from, from, reason, password, false, false);

+ handleGeneralMUCInvitation(inviteEvent);

+}

+

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <vector>

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <boost/signals2.hpp>

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/Elements/SecurityLabelsCatalog.h>

+#include <Swiften/Elements/Stanza.h>

+#include <Swiften/JID/JID.h>

+#include <Swiften/MUC/MUCRegistry.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>

+#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatMessageParser;

+ class Chattables;

+ class ChatWindowFactory;

+ class EntityCapsProvider;

+ class EventController;

+ class Highlighter;

+ class HighlightManager;

+ class IQRouter;

+ class NickResolver;

+ class StanzaChannel;

+ class UIEventStream;

+

+ class ChatControllerBase : public boost::signals2::trackable {

+ public:

+ class StreamWindowMessageIDPair {

+ public:

+ std::string idInStream;

+ std::string idInWindow;

+ };

+

+ public:

+ virtual ~ChatControllerBase();

+ void showChatWindow();

+ void activateChatWindow();

+ bool hasOpenWindow() const;

+ virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info);

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> /*message*/) {}

+ void handleIncomingMessage(std::shared_ptr<MessageEvent> message);

+ std::string addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time);

+ void replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time);

+ virtual void setOnline(bool online);

+ void setEnabled(bool enabled);

+ virtual void setToJID(const JID& jid) {toJID_ = jid;}

+ /** Used for determining when something is recent.*/

+ boost::signals2::signal<void (const std::string& /*activity*/)> onActivity;

+ boost::signals2::signal<void ()> onUnreadCountChanged;

+ boost::signals2::signal<void ()> onWindowClosed;

+ size_t getUnreadCount();

+ const JID& getToJID() {return toJID_;}

+ void handleCapsChanged(const JID& jid);

+ void setCanStartImpromptuChats(bool supportsImpromptu);

+ virtual ChatWindow* detachChatWindow();

+ boost::signals2::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;

+

+ protected:

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ /**

+ * Pass the Message appended, and the stanza used to send it.

+ */

+ virtual void postSendMessage(const std::string&, std::shared_ptr<Stanza>) {}

+ virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) = 0;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message>) = 0;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) {}

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) = 0;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& chatMessage, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) = 0;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage&) {}

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) {}

+ virtual bool isFromContact(const JID& from);

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const = 0;

+ virtual void dayTicked() {}

+ virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

+ std::string getErrorMessage(std::shared_ptr<ErrorPayload>);

+ virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

+ virtual void cancelReplaces() = 0;

+ /** JID any iq for account should go to - bare except for PMs */

+ virtual JID getBaseJID();

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) = 0;

+ ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);

+ void updateMessageCount();

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> /* message */) {

+ return false;

+ }

+ /**

+ * What JID should be used for last message correction (XEP-0308) tracking.

+ */

+ virtual JID messageCorrectionJID(const JID& fromJID) = 0;

+ virtual void handleResendMessageRequest(const std::string& id);

+ private:

+ IDGenerator idGenerator_;

+ std::string lastSentMessageStanzaID_;

+ void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

+ void handleAllMessagesRead();

+ void handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

+ void handleMUCInvitation(Message::ref message);

+ void handleMediatedMUCInvitation(Message::ref message);

+ void handleGeneralMUCInvitation(MUCInviteEvent::ref event);

+ void handleContinuationsBroken();

+ protected:

+ JID selfJID_;

+ std::vector<std::shared_ptr<StanzaEvent> > unreadMessages_;

+ std::vector<std::shared_ptr<StanzaEvent> > targetedUnreadMessages_;

+ StanzaChannel* stanzaChannel_;

+ IQRouter* iqRouter_;

+ ChatWindowFactory* chatWindowFactory_;

+ ChatWindow* chatWindow_;

+ JID toJID_;

+ bool labelsEnabled_;

+ std::map<JID, StreamWindowMessageIDPair> lastMessagesIDs_;

+ PresenceOracle* presenceOracle_;

+ AvatarManager* avatarManager_;

+ bool useDelayForLatency_;

+ EventController* eventController_;

+ EntityCapsProvider* entityCapsProvider_;

+ SecurityLabelsCatalog::Item lastLabel_;

+ HistoryController* historyController_;

+ MUCRegistry* mucRegistry_;

+ Highlighter* highlighter_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UIEventStream* eventStream_;

+ bool lastWasPresence_ = false;

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

+ std::map<std::string, std::string> requestedReceipts_;

+ std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+ Chattables& chattables_;

+ };

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+#include <boost/version.hpp>

+#include <boost/algorithm/string.hpp>

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/archive/text_oarchive.hpp>

+#include <boost/bind.hpp>

+#include <boost/serialization/map.hpp>

+#include <boost/serialization/optional.hpp>

+#include <boost/serialization/split_free.hpp>

+#include <boost/serialization/string.hpp>

+#include <boost/serialization/vector.hpp>

+

+#include <Swift/Controllers/UIInterfaces/ChatListWindow.h>

+

+BOOST_CLASS_VERSION(Swift::ChatListWindow::Chat, 3)

+namespace Swift {

+ const boost::archive::library_version_type BoostArchiveSkipVersion(15);

+}

+

+namespace boost {

+ namespace serialization {

+ template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {

+ std::string jidStr = jid.toString();

+ ar << jidStr;

+ }

+

+ template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {

+ std::string stringJID;

+ ar >> stringJID;

+ jid = Swift::JID(stringJID);

+ }

+

+ template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version) {

+ split_free(ar, t, file_version);

+ }

+

+ template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int version) {

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ int archiveVersion = 0;

+ archive::text_oarchive* outputStream = dynamic_cast<archive::text_oarchive*>(&ar);

+ if (outputStream) {

+ archiveVersion = outputStream->get_library_version();

+ }

+ archive::text_iarchive* inputStream = dynamic_cast<archive::text_iarchive*>(&ar);

+ if (inputStream) {

+ archiveVersion = inputStream->get_library_version();

+ //Due to https://svn.boost.org/trac10/ticket/13050 the password field may fail to load and crash the client. Therefore we skip loading the values from previous versions.

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion && archiveLibraryVersion > archiveVersion) {

+ return;

+ }

+ }

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ if (version > 0) {

+ if (outputStream && archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ //The bug does not affect the case boost::optional doesn't have a value. Therefore we store always that value, to avoid problem on future launches of the client.

+ boost::optional<std::string> empty;

+ ar & empty;

+ }

+ else {

+ ar & chat.password;

+ }

+ }

+ if (version > 1) {

+ ar & chat.inviteesNames;

+ }

+ }

+ }

+}

+ * Copyright (c) 2013-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <algorithm>

+#include <memory>

+#include <vector>

+#include <boost/regex.hpp>

+#include <Swiften/Base/String.h>

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode) : emoticons_(emoticons), highlightConfiguration_(highlightConfiguration), mode_(mode) {

+ }

+

+ typedef std::pair<std::string, std::string> StringPair;

+

+ ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body, const std::string& senderNickname, bool senderIsSelf) {

+ ChatWindow::ChatMessage parsedMessage;

+

+ std::string remaining = body;

+ if (boost::starts_with(body, "/me ")) {

+ remaining = String::getSplittedAtFirst(body, ' ').second;

+ parsedMessage.setIsMeCommand(true);

+ }

+

+ /* Parse one, URLs */

+ while (!remaining.empty()) {

+ bool found = false;

+ std::pair<std::vector<std::string>, size_t> links = Linkify::splitLink(remaining);

+ remaining = "";

+ for (size_t i = 0; i < links.first.size(); i++) {

+ const std::string& part = links.first[i];

+ if (found) {

+ // Must be on the last part, then

+ remaining = part;

+ }

+ else {

+ if (i == links.second) {

+ found = true;

+ parsedMessage.append(std::make_shared<ChatWindow::ChatURIMessagePart>(part));

+ }

+ else {

+ parsedMessage.append(std::make_shared<ChatWindow::ChatTextMessagePart>(part));

+ }

+ }

+ }

+ }

+

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

+ if (!senderIsSelf) { /* do not highlight our own messsages */

+ // Highlight keywords and own mentions.

+ parsedMessage = splitHighlight(parsedMessage);

+

+ // Highlight full message events like, specific sender, general

+ // incoming group message, or general incoming direct message.

+ parsedMessage = fullMessageHighlight(parsedMessage, senderNickname);

+ }

+

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::emoticonHighlight(const ChatWindow::ChatMessage& message) {

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ std::string regexString;

+ /* Parse two, emoticons */

+ for (StringPair emoticon : emoticons_) {

+ /* Construct a regexp that finds an instance of any of the emoticons inside a group

+ * at the start or end of the line, or beside whitespace.

+ */

+ regexString += regexString.empty() ? "" : "|";

+ std::string escaped = "(" + Regex::escape(emoticon.first) + ")";

+ regexString += "^" + escaped + "|";

+ regexString += escaped + "$|";

+ regexString += "\\s" + escaped + "|";

+ regexString += escaped + "\\s";

+

+ }

+ if (!regexString.empty()) {

+ regexString += "";

+ boost::regex emoticonRegex(regexString);

+

+ ChatWindow::ChatMessage newMessage;

+ for (const auto& part : parsedMessage.getParts()) {

+ std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

+ try {

+ boost::match_results<std::string::const_iterator> match;

+ const std::string& text = textPart->text;

+ std::string::const_iterator start = text.begin();

+ while (regex_search(start, text.end(), match, emoticonRegex)) {

+ int matchIndex = 0;

+ for (matchIndex = 1; matchIndex < static_cast<int>(match.size()); matchIndex++) {

+ if (match[matchIndex].length() > 0) {

+ //This is the matching subgroup

+ break;

+ }

+ }

+ std::string::const_iterator matchStart = match[matchIndex].first;

+ std::string::const_iterator matchEnd = match[matchIndex].second;