2 files changed, 4 insertions, 1 deletions
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index a2b286f..557aef4 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -515,70 +515,74 @@ ChatController* ChatsManager::getChatControllerOrCreate(const JID &contact) {
 
 ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {
 	if (chatControllers_.find(contact) == chatControllers_.end()) {
 		if (mucRegistry_->isMUC(contact.toBare())) {
 			return NULL;
 		}
 		//Need to look for an unbound window to bind first
 		JID bare(contact.toBare());
 		if (chatControllers_.find(bare) != chatControllers_.end()) {
 			rebindControllerJID(bare, contact);
 		} else {
 			foreach (JIDChatControllerPair pair, chatControllers_) {
 				if (pair.first.toBare() == contact.toBare()) {
 					if (rebindIfNeeded) {
 						rebindControllerJID(pair.first, contact);
 						return chatControllers_[contact];
 					} else {
 						return pair.second;
 					}
 
 				}
 			}
 			return NULL;
 		}
 	}
 	return chatControllers_[contact];
 }
 
 void ChatsManager::rebindControllerJID(const JID& from, const JID& to) {
 	chatControllers_[to] = chatControllers_[from];
 	chatControllers_.erase(from);
 	chatControllers_[to]->setToJID(to);
 }
 
 void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew) {
+	if (!stanzaChannel_->isAvailable()) {
+		/* This is potentially not the optimal solution, but it will avoid consistency issues.*/
+		return;
+	}
 	if (addAutoJoin) {
 		MUCBookmark bookmark(mucJID, mucJID.getNode());
 		bookmark.setAutojoin(true);
 		if (nickMaybe) {
 			bookmark.setNick(*nickMaybe);
 		}
 		mucBookmarkManager_->addBookmark(bookmark);
 	}
 
 	std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);
 	if (it != mucControllers_.end()) {
 		it->second->rejoin();
 	} else {
 		std::string nick = (nickMaybe && !(*nickMaybe).empty()) ? nickMaybe.get() : nickResolver_->jidToNick(jid_);
 		MUC::ref muc = mucManager->createMUC(mucJID);
 		if (createAsReservedIfNew) {
 			muc->setCreateAsReservedIfNew();
 		}
 		MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_);
 		mucControllers_[mucJID] = controller;
 		controller->setAvailableServerFeatures(serverDiscoInfo_);
 		controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));
 		controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));
 		controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));
 		controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
 		handleChatActivity(mucJID.toBare(), "", true);
 	}
 
 	mucControllers_[mucJID]->showChatWindow();
 }
 
 void ChatsManager::handleSearchMUCRequest() {
 	mucSearchController_->openSearchWindow();
 }
 
diff --git a/Swiften/MUC/MUC.cpp b/Swiften/MUC/MUC.cpp
index 9bcb279..a52f552 100644
--- a/Swiften/MUC/MUC.cpp
+++ b/Swiften/MUC/MUC.cpp
@@ -27,71 +27,70 @@
 
 namespace Swift {
 
 typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;
 
 MUC::MUC(StanzaChannel* stanzaChannel, IQRouter* iqRouter, DirectedPresenceSender* presenceSender, const JID &muc, MUCRegistry* mucRegistry) : ownMUCJID(muc), stanzaChannel(stanzaChannel), iqRouter_(iqRouter), presenceSender(presenceSender), mucRegistry(mucRegistry), createAsReservedIfNew(false), unlocking(false) {
 	scopedConnection_ = stanzaChannel->onPresenceReceived.connect(boost::bind(&MUC::handleIncomingPresence, this, _1));
 }
 
 //FIXME: discover reserved nickname
 
 /**
  * Join the MUC with default context.
  */
 void MUC::joinAs(const std::string &nick) {
 	joinSince_ = boost::posix_time::not_a_date_time;
 	internalJoin(nick);
 }
 
 /**
  * Set the password used for entering the room.
  */
 void MUC::setPassword(const boost::optional<std::string>& newPassword) {
 	password = newPassword;
 }
 
 /**
  * Join the MUC with context since date.
  */
 void MUC::joinWithContextSince(const std::string &nick, const boost::posix_time::ptime& since) {
 	joinSince_ = since;
 	internalJoin(nick);
 }
 
 void MUC::internalJoin(const std::string &nick) {
-	//TODO: password
 	//TODO: history request
 	joinComplete_ = false;
 	joinSucceeded_ = false;
 
 	mucRegistry->addMUC(getJID());
 
 	ownMUCJID = JID(ownMUCJID.getNode(), ownMUCJID.getDomain(), nick);
 
 	Presence::ref joinPresence = boost::make_shared<Presence>(*presenceSender->getLastSentUndirectedPresence());
 	assert(joinPresence->getType() == Presence::Available);
 	joinPresence->setTo(ownMUCJID);
 	MUCPayload::ref mucPayload = boost::make_shared<MUCPayload>();
 	if (joinSince_ != boost::posix_time::not_a_date_time) {
 		mucPayload->setSince(joinSince_);
 	}
 	if (password) {
 		mucPayload->setPassword(*password);
 	}
 	joinPresence->addPayload(mucPayload);
 
 	presenceSender->sendPresence(joinPresence);
 }
 
 void MUC::part() {
 	presenceSender->removeDirectedPresenceReceiver(ownMUCJID, DirectedPresenceSender::AndSendPresence);
 	mucRegistry->removeMUC(getJID());
 }
 
 void MUC::handleUserLeft(LeavingType type) {
 	std::map<std::string,MUCOccupant>::iterator i = occupants.find(ownMUCJID.getResource());
 	if (i != occupants.end()) {
 		MUCOccupant me = i->second;
 		occupants.erase(i);
 		onOccupantLeft(me, type, "");
 	}