+ * Copyright (c) 2010-2014 Kevin Smith and Remko Tronçon

+#include <cstdlib>

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+

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

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

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

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ ftOverview_(NULL),

+ emoticons_(emoticons) {

+ historyController_ = NULL;

+ historyViewController_ = NULL;

+ blockListController_ = NULL;

+ showProfileController_ = NULL;

+ userSearchControllerInvite_ = NULL;

+ contactsFromRosterProvider_ = NULL;

+ contactSuggesterWithoutRoster_ = NULL;

+ contactSuggesterWithRoster_ = NULL;

+ whiteboardManager_ = NULL;

+

+ highlightManager_ = new HighlightManager(settings_);

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

+

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

+ ClientOptions cachedOptions;

+ ClientOptions clientOptions = parseClientOptions(profileSettings.getStringSetting("options"));

+ loginWindow_->addAvailableAccount(jid, password, certificate, clientOptions);

+ cachedOptions = clientOptions;

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

+ handleLoginRequest(selectedLoginJID, cachedPassword, cachedCertificate, CertificateWithKey::ref(), cachedOptions, true, true);

+ delete highlightEditorController_;

+ delete highlightManager_;

+ delete showProfileController_;

+ showProfileController_ = NULL;

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ delete historyViewController_;

+ historyViewController_ = NULL;

+ delete historyController_;

+ historyController_ = NULL;

+#endif

+ delete blockListController_;

+ blockListController_ = NULL;

+ delete userSearchControllerInvite_;

+ userSearchControllerInvite_ = NULL;

+ delete contactSuggesterWithoutRoster_;

+ contactSuggesterWithoutRoster_ = NULL;

+ delete contactSuggesterWithRoster_;

+ contactSuggesterWithRoster_ = NULL;

+ delete contactsFromRosterProvider_;

+ contactsFromRosterProvider_ = NULL;

+ delete whiteboardManager_;

+ whiteboardManager_ = NULL;

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

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

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

+

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

+ 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::InviteToChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

+#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_, userSearchControllerInvite_, 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_, NULL, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, userSearchControllerInvite_, client_->getVCardManager());

+#endif

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

+ contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(contactsFromRosterProvider_);

+ highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);

+#ifdef SWIFT_EXPERIMENTAL_WB

+ discoInfo.addFeature(DiscoInfo::WhiteboardFeature);

+#endif

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

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

+

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

+ rosterController_->setJID(boundJID_);

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

+

+ assert(chatsManager_);

+ adHocManager_->setOnline(true);

+ if (statusTracker_->goAutoAway(idleDetector_->getIdleTimeSeconds())) {

+void MainController::handleShowCertificateRequest() {

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

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

+}

+

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

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

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

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

+ clientOptions_ = options;

+ ClientOptions clientOptions = clientOptions_;

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

+ if (rosterController_) {

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

+ }

+ if (adHocManager_) {

+ adHocManager_->setOnline(false);

+ }

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

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

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

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

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

+ rosterController_->initBlockingCommand();

+ }

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

+ std::string hash;

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

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

+ }

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

+ return result;

+}

+

+#define CHECK_PARSE_LENGTH if (i >= segments.size()) {return result;}

+#define PARSE_INT_RAW(defaultValue) CHECK_PARSE_LENGTH intVal = defaultValue; try {intVal = boost::lexical_cast<int>(segments[i]);} catch(const boost::bad_lexical_cast&) {};i++;

+#define PARSE_STRING_RAW CHECK_PARSE_LENGTH stringVal = byteArrayToString(Base64::decode(segments[i]));i++;

+

+#define PARSE_BOOL(option, defaultValue) PARSE_INT_RAW(defaultValue); result.option = (intVal == 1);

+#define PARSE_INT(option, defaultValue) PARSE_INT_RAW(defaultValue); result.option = intVal;

+#define PARSE_STRING(option) PARSE_STRING_RAW; result.option = stringVal;

+#define PARSE_SAFE_STRING(option) PARSE_STRING_RAW; result.option = SafeString(createSafeByteArray(stringVal));

+#define PARSE_URL(option) {PARSE_STRING_RAW; result.option = URL::fromString(stringVal);}

+

+

+ClientOptions MainController::parseClientOptions(const std::string& optionString) {

+ ClientOptions result;

+ size_t i = 0;

+ int intVal = 0;

+ std::string stringVal;

+ std::vector<std::string> segments = String::split(optionString, ',');

+

+ PARSE_BOOL(useStreamCompression, 1);

+ PARSE_INT_RAW(-1);

+ switch (intVal) {

+ case 1: result.useTLS = ClientOptions::NeverUseTLS;break;

+ case 2: result.useTLS = ClientOptions::UseTLSWhenAvailable;break;

+ case 3: result.useTLS = ClientOptions::RequireTLS;break;

+ default:;

+ }

+ PARSE_BOOL(allowPLAINWithoutTLS, 0);

+ PARSE_BOOL(useStreamResumption, 0);

+ PARSE_BOOL(useAcks, 1);

+ PARSE_STRING(manualHostname);

+ PARSE_INT(manualPort, -1);

+ PARSE_INT_RAW(-1);

+ switch (intVal) {

+ case 1: result.proxyType = ClientOptions::NoProxy;break;

+ case 2: result.proxyType = ClientOptions::SystemConfiguredProxy;break;

+ case 3: result.proxyType = ClientOptions::SOCKS5Proxy;break;

+ case 4: result.proxyType = ClientOptions::HTTPConnectProxy;break;

+ }

+ PARSE_STRING(manualProxyHostname);

+ PARSE_INT(manualProxyPort, -1);

+ PARSE_URL(boshURL);

+ PARSE_URL(boshHTTPConnectProxyURL);

+ PARSE_SAFE_STRING(boshHTTPConnectProxyAuthID);

+ PARSE_SAFE_STRING(boshHTTPConnectProxyAuthPassword);

+

+ return result;

+}

+