1 files changed, 72 insertions, 23 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index d10e6d4..30d4933 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/MUCController.h>
 
 #include <algorithm>
 #include <cassert>
 #include <memory>
@@ -17,30 +17,32 @@
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Tristate.h>
 #include <Swiften/Client/BlockList.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
+#include <Swiften/Disco/GetDiscoInfoRequest.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/Thread.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/Network/Timer.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Roster/XMPPRoster.h>
 
 #include <SwifTools/TabComplete.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
+#include <Swift/Controllers/Chat/Chattables.h>
 #include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Roster/RosterVCardProvider.h>
@@ -53,29 +55,18 @@
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 
 #define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000
 
 namespace Swift {
 
-class MUCBookmarkPredicate {
-    public:
-        MUCBookmarkPredicate(const JID& mucJID) : roomJID_(mucJID) { }
-        bool operator()(const MUCBookmark& operand) {
-            return operand.getRoom() == roomJID_;
-        }
-
-    private:
-        JID roomJID_;
-};
-
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
 MUCController::MUCController (
         const JID& self,
         MUC::ref muc,
         const boost::optional<std::string>& password,
         const std::string &nick,
         StanzaChannel* stanzaChannel,
@@ -92,33 +83,35 @@ MUCController::MUCController (
         XMPPRoster* xmppRoster,
         HistoryController* historyController,
         MUCRegistry* mucRegistry,
         HighlightManager* highlightManager,
         ClientBlockListManager* clientBlockListManager,
         std::shared_ptr<ChatMessageParser> chatMessageParser,
         bool isImpromptu,
         AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,
         VCardManager* vcardManager,
-        MUCBookmarkManager* mucBookmarkManager) :
-    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
+        MUCBookmarkManager* mucBookmarkManager,
+        SettingsProvider* settings,
+        Chattables& chattables) :
+    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings, chattables), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
     assert(avatarManager_);
 
     parting_ = true;
     joined_ = false;
     lastWasPresence_ = false;
     shouldJoinOnReconnect_ = true;
     doneGettingHistory_ = false;
     xmppRoster_ = xmppRoster;
     subject_ = "";
     isInitialJoin_ = true;
     chatWindowTitle_ = "";
 
-    roster_ = std::unique_ptr<Roster>(new Roster(false, true));
+    roster_ = std::make_unique<Roster>(false, true);
     rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);
     completer_ = new TabComplete();
     chatWindow_->setRosterModel(roster_.get());
     chatWindow_->setTabComplete(completer_);
     chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));
     chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));
     chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));
     chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));
     chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));
@@ -165,26 +158,19 @@ MUCController::MUCController (
 
     MUCController::handleBareJIDCapsChanged(muc->getJID());
     eventStream_->onUIEvent.connect(boost::bind(&MUCController::handleUIEvent, this, _1));
 
 
     // setup handling of MUC bookmark changes
     mucBookmarkManagerBookmarkAddedConnection_ = (mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&MUCController::handleMUCBookmarkAdded, this, _1)));
     mucBookmarkManagerBookmarkRemovedConnection_ = (mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&MUCController::handleMUCBookmarkRemoved, this, _1)));
 
-    std::vector<MUCBookmark> mucBookmarks = mucBookmarkManager_->getBookmarks();
-    std::vector<MUCBookmark>::iterator bookmarkIterator = std::find_if(mucBookmarks.begin(), mucBookmarks.end(), MUCBookmarkPredicate(muc->getJID()));
-    if (bookmarkIterator != mucBookmarks.end()) {
-        updateChatWindowBookmarkStatus(*bookmarkIterator);
-    }
-    else {
-        updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());
-    }
+    updateChatWindowBookmarkStatus(mucBookmarkManager_->lookupBookmark(muc->getJID()));
 }
 
 MUCController::~MUCController() {
     eventStream_->onUIEvent.disconnect(boost::bind(&MUCController::handleUIEvent, this, _1));
     chatWindow_->setRosterModel(nullptr);
     delete rosterVCardProvider_;
     if (loginCheckTimer_) {
         loginCheckTimer_->stop();
     }
@@ -267,18 +253,21 @@ void MUCController::rejoin() {
         if (password_) {
             muc_->setPassword(*password_);
         }
         //FIXME: check for received activity
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
         if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {
             lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);
         }
 #endif
+
+        requestSecurityMarking();
+
         if (lastActivity_ == boost::posix_time::not_a_date_time) {
             muc_->joinAs(nick_);
         }
         else {
             muc_->joinWithContextSince(nick_, lastActivity_);
         }
     }
 }
 
@@ -486,18 +475,19 @@ void MUCController::setAvailableRoomActions(const MUCOccupant::Affiliation& affi
     if (affiliation <= MUCOccupant::Admin) {
         actions.push_back(ChatWindow::Affiliations);
     }
     if (affiliation == MUCOccupant::Owner) {
         actions.push_back(ChatWindow::Destroy);
     }
     if (role <= MUCOccupant::Visitor) {
         actions.push_back(ChatWindow::Invite);
     }
+    actions.push_back(ChatWindow::Leave);
     chatWindow_->setAvailableRoomActions(actions);
 }
 
 void MUCController::clearPresenceQueue() {
     lastWasPresence_ = false;
     joinParts_.clear();
 }
 
 std::string MUCController::roleToFriendlyName(MUCOccupant::Role role) {
@@ -1237,10 +1227,69 @@ void MUCController::displaySubjectIfChanged(const std::string& subject) {
 void MUCController::addChatSystemMessage() {
     lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);
 }
 
 void MUCController::setChatWindowTitle(const std::string& title) {
     chatWindowTitle_ = title;
     chatWindow_->setName(chatWindowTitle_);
 }
 
+void MUCController::requestSecurityMarking() {
+    auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);
+    discoInfoRequest->onResponse.connect(
+        [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {
+            if (!discoInfoRef || errorPayloadRef) {
+                return;
+            }
+            const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();
+            if (extensionsList.empty()) {
+                return;
+            }
+            // Get the correct form if it exists
+            Form::ref roomInfoForm;
+            for (const auto& form : extensionsList) {
+                if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {
+                    roomInfoForm = form;
+                    break;
+                }
+            }
+            if (!roomInfoForm) {
+                return;
+            }
+            // It exists, now examine the security marking data
+            auto marking = roomInfoForm->getField("x-isode#roominfo_marking");
+            if (!marking) {
+                return;
+            }
+            // Now we know the marking is valid
+            auto markingValue = marking->getTextSingleValue();
+            if (markingValue == "") {
+                setMUCSecurityMarkingDefault();
+                return;
+            }
+            auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");
+            auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");
+            std::string markingForegroundColorValue = "Black";
+            std::string markingBackgroundColorValue = "White";
+            if (markingForegroundColor && markingForegroundColor->getTextSingleValue() != "") {
+                markingForegroundColorValue = markingForegroundColor->getTextSingleValue();
+            }
+            if (markingBackgroundColor && markingBackgroundColor->getTextSingleValue() != "") {
+                markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();
+            }
+            setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
+        }
+    );
+    discoInfoRequest->send();
+}
+
+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {
+    roomSecurityMarking_ = markingValue;
+    chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
+}
+
+void MUCController::setMUCSecurityMarkingDefault() {
+    roomSecurityMarking_ = "";
+    chatWindow_->removeChatSecurityMarking();
+}
+
 }