Made Anope keep track of channels its clients are in if it splits from its uplink, then burst them back to its uplink once connection is reestablished.

Also made Anope use TS enforcement to change persistant channels creation time to the time they were registered.

9 files changed, 231 insertions, 131 deletions

diff --git a/src/bots.cpp b/src/bots.cpp
index cb7a370c1..d63f6787f 100644
--- a/src/bots.cpp
+++ b/src/bots.cpp
@@ -49,7 +49,7 @@ BotInfo::BotInfo(const Anope::string &nnick, const Anope::string &nuser, const A
 	if (!this->uid.empty())
 		BotListByUID[this->uid] = this;
 
-	// If we're synchronised with the uplink already, call introduce_user() for this bot.
+	// If we're synchronised with the uplink already, send the bot.
 	if (Me && !Me->GetLinks().empty() && Me->GetLinks().front()->IsSynced())
 	{
 		ircdproto->SendClientIntroduction(this->nick, this->GetIdent(), this->host, this->realname, ircd->pseudoclient_mode, this->uid);
@@ -136,7 +136,7 @@ void BotInfo::UnAssign(User *u, ChannelInfo *ci)
 	ci->bi = NULL;
 }
 
-void BotInfo::Join(Channel *c)
+void BotInfo::Join(Channel *c, bool update_ts)
 {
 	if (Config->BSSmartJoin)
 	{
@@ -162,19 +162,39 @@ void BotInfo::Join(Channel *c)
 			if (c->HasMode(CMODE_INVITE) || (limit && c->users.size() >= limit))
 				ircdproto->SendNoticeChanops(this, c, "%s invited %s into the channel.", this->nick.c_str(), this->nick.c_str());
 		}
+
+		ModeManager::ProcessModes();
 	}
 
-	ircdproto->SendJoin(this, c->name, c->creation_time);
-	for (std::list<ChannelModeStatus *>::iterator it = BotModes.begin(), it_end = BotModes.end(); it != it_end; ++it)
-		c->SetMode(this, *it, this->nick, false);
 	c->JoinUser(this);
+	ChannelContainer *cc = this->FindChannel(c);
+	for (std::list<ChannelModeStatus *>::iterator it = BotModes.begin(), it_end = BotModes.end(); it != it_end; ++it)
+	{
+		if (!update_ts)
+		{
+			c->SetMode(this, *it, this->nick, false);
+		}
+		else
+		{
+			cc->Status->SetFlag((*it)->Name);
+			c->SetModeInternal(*it, this->nick, false);
+		}
+	}
+	if (!update_ts)
+		ircdproto->SendJoin(this, c->name, c->creation_time);
+	else
+	{
+		ircdproto->SendJoin(this, cc);
+		
+		c->Reset();
+	}
 	FOREACH_MOD(I_OnBotJoin, OnBotJoin(c->ci, this));
 }
 
-void BotInfo::Join(const Anope::string &chname)
+void BotInfo::Join(const Anope::string &chname, bool update_ts)
 {
 	Channel *c = findchan(chname);
-	return this->Join(c ? c : new Channel(chname));
+	return this->Join(c ? c : new Channel(chname), update_ts);
 }
 
 void BotInfo::Part(Channel *c, const Anope::string &reason)
diff --git a/src/channels.cpp b/src/channels.cpp
index a10a4e675..709d9cf01 100644
--- a/src/channels.cpp
+++ b/src/channels.cpp
@@ -75,6 +75,28 @@ Channel::~Channel()
 	ChannelList.erase(this->name);
 }
 
+void Channel::Reset()
+{
+	this->ClearModes(NULL, false);
+	this->ClearBans(NULL, false);
+	this->ClearExcepts(NULL, false);
+	this->ClearInvites(NULL, false);
+
+	for (CUserList::const_iterator it = this->users.begin(), it_end = this->users.end(); it != it_end; ++it)
+	{
+		UserContainer *uc = *it;
+
+		if (findbot(uc->user->nick))
+			continue;
+
+		uc->Status->ClearFlags();
+	}
+	
+	check_modes(this);
+	for (CUserList::const_iterator it = this->users.begin(), it_end = this->users.end(); it != it_end; ++it)
+		chan_set_correct_modes((*it)->user, this, 1);
+}
+
 void Channel::Sync()
 {
 	if (this->users.empty() || (this->users.size() == 1 && this->ci && this->ci->bi == this->users.front()->user))
@@ -84,7 +106,6 @@ void Channel::Sync()
 	if (this->ci)
 	{
 		check_modes(this);
-		stick_all(this->ci);
 	}
 
 	if (Me && Me->IsSynced() && !this->topic_sync)
@@ -95,7 +116,7 @@ void Channel::JoinUser(User *user)
 {
 	Alog(LOG_DEBUG) << user->nick << " joins " << this->name;
 
-	Flags<ChannelModeName> *Status = new Flags<ChannelModeName>;
+	ChannelStatus *Status = new ChannelStatus();
 	ChannelContainer *cc = new ChannelContainer(this);
 	cc->Status = Status;
 	user->chans.push_back(cc);
@@ -104,6 +125,14 @@ void Channel::JoinUser(User *user)
 	uc->Status = Status;
 	this->users.push_back(uc);
 
+	bool update_ts = false;
+	if (this->ci && this->ci->HasFlag(CI_PERSIST) && this->creation_time > this->ci->time_registered)
+	{
+		Alog(LOG_DEBUG) << "Changing TS of " << this->name << " from " << this->creation_time << " to " << this->ci->time_registered;
+		this->creation_time = this->ci->time_registered;
+		update_ts = true;
+	}
+
 	if (!get_ignore(user->nick))
 	{
 		if (this->ci && check_access(user, this->ci, CA_MEMO) && this->ci->memos.memos.size() > 0)
@@ -126,11 +155,9 @@ void Channel::JoinUser(User *user)
 		 * and the ignored user doesnt just leave, the bot will never
 		 * make it into the channel, leaving the channel botless even for
 		 * legit users - Rob
-		 * But don't join the bot if the channel is persistant - Adam
-		 * But join persistant channels when syncing with our uplink- DP
 		 **/
-		if ((!Me->IsSynced() || !this->ci->HasFlag(CI_PERSIST)) && this->users.size() >= Config->BSMinUsers && !this->FindUser(this->ci->bi))
-			this->ci->bi->Join(this);
+		if (this->users.size() >= Config->BSMinUsers && !this->FindUser(this->ci->bi))
+			this->ci->bi->Join(this, update_ts);
 		/* Only display the greet if the main uplink we're connected
 		 * to has synced, or we'll get greet-floods when the net
 		 * recovers from a netsplit. -GD
@@ -141,6 +168,16 @@ void Channel::JoinUser(User *user)
 			this->ci->bi->lastmsg = time(NULL);
 		}
 	}
+
+	if (update_ts)
+	{
+		/* Send the updated TS */
+		if (!this->ci->bi || !this->FindUser(this->ci->bi))
+		{
+			whosends(this->ci)->Join(this, update_ts);
+			whosends(this->ci)->Part(this);
+		}
+	}
 }
 
 /** Remove a user internally from the channel
@@ -296,7 +333,8 @@ void Channel::SetModeInternal(ChannelMode *cm, const Anope::string &param, bool
 			cc->Status->SetFlag(cm->Name);
 
 		/* Enforce secureops, etc */
-		chan_set_correct_modes(u, this, 0);
+		if (EnforceMLock)
+			chan_set_correct_modes(u, this, 0);
 		return;
 	}
 	/* Setting b/e/I etc */
@@ -654,24 +692,31 @@ bool Channel::HasParam(ChannelModeName Name) const
 
 /** Clear all the modes from the channel
  * @param bi The client setting the modes
+ * @param internal Only remove the modes internally
  */
-void Channel::ClearModes(BotInfo *bi)
+void Channel::ClearModes(BotInfo *bi, bool internal)
 {
-	ChannelMode *cm;
-
 	for (size_t n = CMODE_BEGIN + 1; n != CMODE_END; ++n)
 	{
-		cm = ModeManager::FindChannelModeByName(static_cast<ChannelModeName>(n));
+		ChannelMode *cm = ModeManager::FindChannelModeByName(static_cast<ChannelModeName>(n));
 
 		if (cm && this->HasMode(cm->Name))
 		{
 			if (cm->Type == MODE_REGULAR)
-				this->RemoveMode(NULL, cm);
+			{
+				if (!internal)
+					this->RemoveMode(NULL, cm);
+				else
+					this->RemoveModeInternal(cm);
+			}
 			else if (cm->Type == MODE_PARAM)
 			{
 				Anope::string param;
 				this->GetParam(cm->Name, param);
-				this->RemoveMode(NULL, cm, param);
+				if (!internal)
+					this->RemoveMode(NULL, cm, param);
+				else
+					this->RemoveModeInternal(cm, param);
 			}
 		}
 	}
@@ -681,58 +726,67 @@ void Channel::ClearModes(BotInfo *bi)
 
 /** Clear all the bans from the channel
  * @param bi The client setting the modes
+ * @param internal Only remove the modes internally
  */
-void Channel::ClearBans(BotInfo *bi)
+void Channel::ClearBans(BotInfo *bi, bool internal)
 {
 	Entry *entry, *nexte;
-	ChannelModeList *cml;
 
-	cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_BAN));
+	ChannelModeList *cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_BAN));
 
 	if (cml && this->bans && this->bans->count)
 		for (entry = this->bans->entries; entry; entry = nexte)
 		{
 			nexte = entry->next;
 
-			this->RemoveMode(bi, CMODE_BAN, entry->mask);
+			if (!internal)
+				this->RemoveMode(bi, cml, entry->mask);
+			else
+				this->RemoveModeInternal(cml, entry->mask);
 		}
 }
 
 /** Clear all the excepts from the channel
  * @param bi The client setting the modes
+ * @param internal Only remove the modes internally
  */
-void Channel::ClearExcepts(BotInfo *bi)
+void Channel::ClearExcepts(BotInfo *bi, bool internal)
 {
 	Entry *entry, *nexte;
-	ChannelModeList *cml;
 
-	cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_EXCEPT));
+	ChannelModeList *cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_EXCEPT));
 
 	if (cml && this->excepts && this->excepts->count)
 		for (entry = this->excepts->entries; entry; entry = nexte)
 		{
 			nexte = entry->next;
 
-			this->RemoveMode(bi, CMODE_EXCEPT, entry->mask);
+			if (!internal)
+				this->RemoveMode(bi, cml, entry->mask);
+			else
+				this->RemoveModeInternal(cml, entry->mask);
 		}
 }
 
 /** Clear all the invites from the channel
  * @param bi The client setting the modes
+ * @param internal Only remove the modes internally
  */
-void Channel::ClearInvites(BotInfo *bi)
+void Channel::ClearInvites(BotInfo *bi, bool internal)
 {
 	Entry *entry, *nexte;
-	ChannelModeList *cml;
 
-	cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE));
+	ChannelModeList *cml = debug_cast<ChannelModeList *>(ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE));
 
 	if (cml && this->invites && this->invites->count)
 		for (entry = this->invites->entries; entry; entry = nexte)
 		{
 			nexte = entry->next;
 
-			this->RemoveMode(bi, CMODE_INVITEOVERRIDE, entry->mask);
+			if (!internal)
+				this->RemoveMode(bi, cml, entry->mask);
+			else
+				this->RemoveModeInternal(cml, entry->mask);
 		}
 }
 
@@ -922,24 +976,21 @@ bool Channel::Kick(BotInfo *bi, User *u, const char *reason, ...)
 	return true;
 }
 
-/* Returns a fully featured binary modes string. If complete is 0, the
- * eventual parameters won't be added to the string.
- */
-
-Anope::string chan_get_modes(Channel *chan, int complete, int plus)
+Anope::string Channel::GetModes(bool complete, bool plus)
 {
-	Anope::string res, params, param;
+	Anope::string res;
 
-	if (chan->HasModes())
+	if (this->HasModes())
 	{
-		for (std::list<Mode *>::iterator it = ModeManager::Modes.begin(), it_end = ModeManager::Modes.end(); it != it_end; ++it)
+		Anope::string params;
+		for (std::map<Anope::string, Mode *>::const_iterator it = ModeManager::Modes.begin(), it_end = ModeManager::Modes.end(); it != it_end; ++it)
 		{
-			if ((*it)->Class != MC_CHANNEL)
+			if (it->second->Class != MC_CHANNEL)
 				continue;
 
-			ChannelMode *cm = debug_cast<ChannelMode *>(*it);
+			ChannelMode *cm = debug_cast<ChannelMode *>(it->second);
 
-			if (chan->HasMode(cm->Name))
+			if (this->HasMode(cm->Name))
 			{
 				res += cm->ModeChar;
 
@@ -951,7 +1002,8 @@ Anope::string chan_get_modes(Channel *chan, int complete, int plus)
 
 						if (plus || !cmp->MinusNoArg)
 						{
-							chan->GetParam(cmp->Name, param);
+							Anope::string param;
+							this->GetParam(cmp->Name, param);
 
 							if (!param.empty())
 								params += " " + param;
@@ -1056,7 +1108,6 @@ User *nc_on_chan(Channel *c, const NickCore *nc)
 void do_join(const Anope::string &source, int ac, const char **av)
 {
 	User *user;
-	Channel *chan;
 	time_t ctime = time(NULL);
 
 	user = finduser(source);
@@ -1085,7 +1136,7 @@ void do_join(const Anope::string &source, int ac, const char **av)
 			continue;
 		}
 
-		chan = findchan(buf);
+		Channel *chan = findchan(buf);
 
 		/* Channel doesn't exist, create it */
 		if (!chan)
@@ -1099,19 +1150,10 @@ void do_join(const Anope::string &source, int ac, const char **av)
 			/* Their time is older, we lose */
 			if (chan->creation_time > ts)
 			{
-				Alog(LOG_DEBUG) << "recieved a new TS for JOIN: " << ts;
+				Alog(LOG_DEBUG) << "Recieved an older TS " << chan->name << " in JOIN, changing from " << chan->creation_time << " to " << ts;
+				chan->creation_time = ts;
 
-				if (chan->ci)
-				{
-					/* Cycle the bot to fix ts */
-					if (chan->ci->bi)
-					{
-						chan->ci->bi->Part(chan, "TS reop");
-						chan->ci->bi->Join(chan);
-					}
-					/* Be sure to set mlock again, else we could be -r etc.. */
-					check_modes(chan);
-				}
+				chan->Reset();
 			}
 		}
 
diff --git a/src/chanserv.cpp b/src/chanserv.cpp
index 03760b9b6..c80de4c75 100644
--- a/src/chanserv.cpp
+++ b/src/chanserv.cpp
@@ -290,8 +290,6 @@ void check_modes(Channel *c)
 		/* If this channel does not have the mode and the mode is mlocked */
 		if (cm->Type == MODE_REGULAR && !c->HasMode(cm->Name) && ci->HasMLock(cm->Name, true))
 		{
-			c->SetMode(NULL, cm);
-
 			/* Add the eventual parameter and modify the Channel structure */
 			if (cm->Type == MODE_PARAM)
 			{
@@ -335,6 +333,8 @@ void check_modes(Channel *c)
 				c->RemoveMode(NULL, cm);
 		}
 	}
+
+	stick_all(ci);
 }
 
 /*************************************************************************/
diff --git a/src/init.cpp b/src/init.cpp
index 35407ec81..d3476a490 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -22,16 +22,16 @@ extern void moduleAddIRCDMsgs();
 void introduce_user(const Anope::string &user)
 {
 	/* Watch out for infinite loops... */
-#define LTSIZE 20
-	static int lasttimes[LTSIZE];
-	if (lasttimes[0] >= time(NULL) - 3)
-		fatal("introduce_user() loop detected");
-	memmove(lasttimes, lasttimes + 1, sizeof(lasttimes) - sizeof(int));
-	lasttimes[LTSIZE - 1] = time(NULL);
-#undef LTSIZE
-	/* We make the bots go online */
+	time_t now = time(NULL);
+	static time_t lasttime = now - 4;
+	if (lasttime >= now - 3)
+		fatal("introduce_user loop detected");
+	lasttime = now;
+
+	if (user.empty())
+		ircdproto->SendBOB();
 
-	/* XXX: it might be nice to have this inside BotInfo's constructor, or something? */
+	/* We make the bots go online */
 	for (botinfo_map::const_iterator it = BotListByNick.begin(), it_end = BotListByNick.end(); it != it_end; ++it)
 	{
 		BotInfo *bi = it->second;
@@ -41,8 +41,20 @@ void introduce_user(const Anope::string &user)
 			ircdproto->SendClientIntroduction(bi->nick, bi->GetIdent(), bi->host, bi->realname, ircd->pseudoclient_mode, bi->GetUID());
 			XLine x(bi->nick, "Reserved for services");
 			ircdproto->SendSQLine(&x);
+
+			for (UChannelList::const_iterator cit = bi->chans.begin(), cit_end = bi->chans.end(); cit != cit_end; ++cit)
+			{
+				ircdproto->SendJoin(bi, *cit);
+			}
 		}
 	}
+
+	if (user.empty())
+	{
+		/* Load MLock from the database now that we know what modes exist */
+		for (registered_channel_map::iterator it = RegisteredChannelList.begin(), it_end = RegisteredChannelList.end(); it != it_end; ++it)
+			it->second->LoadMLock();
+	}
 }
 
 /*************************************************************************/
@@ -66,16 +78,14 @@ static int set_group()
 	if (gr)
 	{
 		setgid(gr->gr_gid);
-		return 0;
 	}
 	else
 	{
-		Alog() << "Unknown group `" << RUNGROUP << "'";
+		Alog() << "Unknown run group '" << RUNGROUP << "'";
 		return -1;
 	}
-#else
-	return 0;
 #endif
+	return 0;
 }
 
 /*************************************************************************/
diff --git a/src/main.cpp b/src/main.cpp
index df7c61c63..bcb67b6fa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -553,15 +553,6 @@ int main(int ac, char **av, char **envp)
 					delete u;
 			}
 
-			/* Nuke all channels */
-			for (channel_map::const_iterator it = ChannelList.begin(); it != ChannelList.end();)
-			{
-				Channel *c = it->second;
-				++it;
-
-				delete c;
-			}
-
 			Me->SetFlag(SERVER_SYNCING);
 			Me->ClearLinks();
 
diff --git a/src/modes.cpp b/src/modes.cpp
index 624023e66..ce34e461c 100644
--- a/src/modes.cpp
+++ b/src/modes.cpp
@@ -13,7 +13,7 @@
 std::list<std::pair<void *, StackerInfo *> > ModeManager::StackerObjects;
 
 /* List of all modes Anope knows about */
-std::list<Mode *> ModeManager::Modes;
+std::map<Anope::string, Mode *> ModeManager::Modes;
 
 /* User modes */
 std::map<char, UserMode *> ModeManager::UserModesByChar;
@@ -91,6 +91,37 @@ void SetDefaultMLock(ServerConfig *config)
 	}
 }
 
+Anope::string ChannelStatus::BuildCharPrefixList() const
+{
+	Anope::string ret;
+
+	for (std::map<char, ChannelMode *>::const_iterator it = ModeManager::ChannelModesByChar.begin(), it_end = ModeManager::ChannelModesByChar.end(); it != it_end; ++it)
+	{
+		if (this->HasFlag(it->second->Name))
+		{
+			ret += it->second->ModeChar;
+		}
+	}
+
+	return ret;
+}
+
+Anope::string ChannelStatus::BuildModePrefixList() const
+{
+	Anope::string ret;
+
+	for (std::map<char, ChannelMode *>::const_iterator it = ModeManager::ChannelModesByChar.begin(), it_end = ModeManager::ChannelModesByChar.end(); it != it_end; ++it)
+	{
+		if (this->HasFlag(it->second->Name))
+		{
+			ChannelModeStatus *cm = debug_cast<ChannelModeStatus *>(it->second);
+			ret += cm->Symbol;
+		}
+	}
+
+	return ret;
+}
+
 /** Default constructor
  * @param mClass The type of mode this is
  * @param mNameAsString The mode name as a string
@@ -607,7 +638,7 @@ bool ModeManager::AddUserMode(UserMode *um)
 			Alog() << "ModeManager: Added generic support for user mode " << um->ModeChar;
 		}
 		ModeManager::UserModesByName.insert(std::make_pair(um->Name, um));
-		ModeManager::Modes.push_back(um);
+		ModeManager::Modes.insert(std::make_pair(um->NameAsString, um));
 
 		FOREACH_MOD(I_OnUserModeAdd, OnUserModeAdd(um));
 
@@ -631,7 +662,7 @@ bool ModeManager::AddChannelMode(ChannelMode *cm)
 			Alog() << "ModeManager: Added generic support for channel mode " << cm->ModeChar;
 		}
 		ModeManager::ChannelModesByName.insert(std::make_pair(cm->Name, cm));
-		ModeManager::Modes.push_back(cm);
+		ModeManager::Modes.insert(std::make_pair(cm->NameAsString, cm));
 
 		/* Apply this mode to the new default mlock if its used */
 		SetDefaultMLock(Config);
@@ -671,6 +702,20 @@ UserMode *ModeManager::FindUserModeByChar(char Mode)
 	return NULL;
 }
 
+/** Find a mode by name
+ * @param name The mode name
+ * @return The mode
+ */
+Mode *ModeManager::FindModeByName(const Anope::string &name)
+{
+	std::map<Anope::string, Mode *>::const_iterator it = ModeManager::Modes.find(name);
+
+	if (it != ModeManager::Modes.end())
+		return it->second;
+	
+	return NULL;
+}
+
 /** Find a channel mode
  * @param Mode The modename
  * @return The mode class
diff --git a/src/protocol.cpp b/src/protocol.cpp
index d0cfef071..dfa7d2b3d 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -197,6 +197,11 @@ void IRCDProto::SendPong(const Anope::string &servname, const Anope::string &who
 		send_cmd(ircd->ts6 ? TS6SID : Config->ServerName, "PONG %s %s", servname.c_str(), who.c_str());
 }
 
+void IRCDProto::SendJoin(BotInfo *bi, const ChannelContainer *cc)
+{
+	SendJoin(bi, cc->chan->name, cc->chan->creation_time);
+}
+
 void IRCDProto::SendInvite(const BotInfo *bi, const Anope::string &chan, const Anope::string &nick)
 {
 	send_cmd(ircd->ts6 ? bi->GetUID() : bi->nick, "INVITE %s %s", nick.c_str(), chan.c_str());
diff --git a/src/regchannel.cpp b/src/regchannel.cpp
index d055a632b..393054acf 100644
--- a/src/regchannel.cpp
+++ b/src/regchannel.cpp
@@ -343,65 +343,60 @@ void ChannelInfo::ClearBadWords()
  */
 void ChannelInfo::LoadMLock()
 {
-	std::vector<Anope::string> modenames;
+	std::vector<Anope::string> modenames_on, modenames_off;
 
-	if (this->GetExtRegular("db_mlock_modes_on", modenames))
+	// Force +r
+	this->SetMLock(CMODE_REGISTERED, true);
+	this->GetExtRegular("db_mlock_modes_on", modenames_on);
+	this->GetExtRegular("db_mlock_modes_off", modenames_off);
+
+	if (!modenames_on.empty() || !modenames_off.empty())
 	{
-		for (std::vector<Anope::string>::iterator it = modenames.begin(), it_end = modenames.end(); it != it_end; ++it)
+		for (std::vector<Anope::string>::iterator it = modenames_on.begin(), it_end = modenames_on.end(); it != it_end; ++it)
 		{
-			for (std::list<Mode *>::iterator mit = ModeManager::Modes.begin(), mit_end = ModeManager::Modes.end(); mit != mit_end; ++mit)
-			{
-				if ((*mit)->Class == MC_CHANNEL)
-				{
-					ChannelMode *cm = debug_cast<ChannelMode *>(*mit);
+			Mode *m = ModeManager::FindModeByName(*it);
 
-					if (cm->NameAsString.equals_ci(*it))
-						this->SetMLock(cm->Name, true);
-				}
+			if (m && m->NameAsString.equals_cs(*it))
+			{
+				ChannelMode *cm = debug_cast<ChannelMode *>(m);
+				this->SetMLock(cm->Name, true);
 			}
 		}
-
-		this->Shrink("db_mlock_modes_on");
-	}
-
-	if (this->GetExtRegular("db_mlock_modes_off", modenames))
-	{
-		for (std::vector<Anope::string>::iterator it = modenames.begin(), it_end = modenames.end(); it != it_end; ++it)
+		for (std::vector<Anope::string>::iterator it = modenames_off.begin(), it_end = modenames_off.end(); it != it_end; ++it)
 		{
-			for (std::list<Mode *>::iterator mit = ModeManager::Modes.begin(), mit_end = ModeManager::Modes.end(); mit != mit_end; ++mit)
-			{
-				if ((*mit)->Class == MC_CHANNEL)
-				{
-					ChannelMode *cm = debug_cast<ChannelMode *>(*mit);
+			Mode *m = ModeManager::FindModeByName(*it);
 
-					if (cm->NameAsString.equals_ci(*it))
-						this->SetMLock(cm->Name, false);
-				}
+			if (m && m->NameAsString.equals_cs(*it))
+			{
+				ChannelMode *cm = debug_cast<ChannelMode *>(m);
+				this->SetMLock(cm->Name, false);
 			}
 		}
-
-		this->Shrink("db_mlock_modes_off");
 	}
 
 	std::vector<std::pair<Anope::string, Anope::string> > params;
-
 	if (this->GetExtRegular("db_mlp", params))
 	{
 		for (std::vector<std::pair<Anope::string, Anope::string> >::iterator it = params.begin(), it_end = params.end(); it != it_end; ++it)
 		{
-			for (std::list<Mode *>::iterator mit = ModeManager::Modes.begin(), mit_end = ModeManager::Modes.end(); mit != mit_end; ++mit)
+			Mode *m = ModeManager::FindModeByName(it->first);
+			if (m && m->Class == MC_CHANNEL)
 			{
-				if ((*mit)->Class == MC_CHANNEL)
-				{
-					ChannelMode *cm = debug_cast<ChannelMode *>(*mit);
-
-					if (cm->NameAsString.equals_ci(it->first))
-						this->SetMLock(cm->Name, true, it->second);
-				}
+				ChannelMode *cm = debug_cast<ChannelMode *>(m);
+				this->SetMLock(cm->Name, true, it->second);
 			}
 		}
+	}
 
-		this->Shrink("db_mlp");
+	/* Create perm channel */
+	if (this->HasFlag(CI_PERSIST) && !this->c)
+	{
+		this->c = new Channel(this->name, this->time_registered);
+		if (!this->bi)
+			ChanServ->Assign(NULL, this);
+		this->bi->Join(c);
+		check_modes(this->c);
+		restore_topic(this->name);
 	}
 }
 
diff --git a/src/servers.cpp b/src/servers.cpp
index 7668cebbf..520cf5f36 100644
--- a/src/servers.cpp
+++ b/src/servers.cpp
@@ -413,14 +413,6 @@ void CapabParse(int ac, const char **av)
 			}
 		}
 	}
-
-	/* Apply MLock now that we know what modes exist (capab is parsed after modes are added to Anope) */
-	for (registered_channel_map::iterator it = RegisteredChannelList.begin(), it_end = RegisteredChannelList.end(); it != it_end; ++it)
-	{
-		ChannelInfo *ci = it->second;
-
-		ci->LoadMLock();
-	}
 }
 
 /*************************************************************************/