1 files changed, 108 insertions, 72 deletions

diff --git a/src/modules/m_delayjoin.cpp b/src/modules/m_delayjoin.cpp
index 20d4c8e8f..acfbfce26 100644
--- a/src/modules/m_delayjoin.cpp
+++ b/src/modules/m_delayjoin.cpp
@@ -20,56 +20,95 @@
  */
 
 
-/* $ModDesc: Allows for delay-join channels (+D) where users don't appear to join until they speak */
-
 #include "inspircd.h"
-#include <stdarg.h>
+#include "modules/ctctags.h"
+#include "modules/names.h"
 
 class DelayJoinMode : public ModeHandler
 {
  private:
-	CUList empty;
+	LocalIntExt& unjoined;
+
  public:
-	DelayJoinMode(Module* Parent) : ModeHandler(Parent, "delayjoin", 'D', PARAM_NONE, MODETYPE_CHANNEL)
+	DelayJoinMode(Module* Parent, LocalIntExt& ext)
+		: ModeHandler(Parent, "delayjoin", 'D', PARAM_NONE, MODETYPE_CHANNEL)
+		, unjoined(ext)
 	{
-		levelrequired = OP_VALUE;
+		ranktoset = ranktounset = OP_VALUE;
 	}
 
-	ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
+	ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
+	void RevealUser(User* user, Channel* chan);
 };
 
-class ModuleDelayJoin : public Module
+
+namespace
 {
-	DelayJoinMode djm;
+
+/** Hook handler for join client protocol events.
+ * This allows us to block join protocol events completely, including all associated messages (e.g. MODE, away-notify AWAY).
+ * This is not the same as OnUserJoin() because that runs only when a real join happens but this runs also when a module
+ * such as hostcycle generates a join.
+ */
+class JoinHook : public ClientProtocol::EventHook
+{
+	const LocalIntExt& unjoined;
+
  public:
-	LocalIntExt unjoined;
-	ModuleDelayJoin() : djm(this), unjoined("delayjoin", this)
+	JoinHook(Module* mod, const LocalIntExt& unjoinedref)
+		: ClientProtocol::EventHook(mod, "JOIN", 10)
+		, unjoined(unjoinedref)
 	{
 	}
 
-	void init()
+	ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) CXX11_OVERRIDE
 	{
-		ServerInstance->Modules->AddService(djm);
-		ServerInstance->Modules->AddService(unjoined);
-		Implementation eventlist[] = { I_OnUserJoin, I_OnUserPart, I_OnUserKick, I_OnBuildNeighborList, I_OnNamesListItem, I_OnText, I_OnRawMode };
-		ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
+		const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev);
+		const Membership* const memb = join.GetMember();
+		const User* const u = memb->user;
+		if ((unjoined.get(memb)) && (u != user))
+			return MOD_RES_DENY;
+		return MOD_RES_PASSTHRU;
 	}
-	~ModuleDelayJoin();
-	Version GetVersion();
-	void OnNamesListItem(User* issuer, Membership*, std::string &prefixes, std::string &nick);
-	void OnUserJoin(Membership*, bool, bool, CUList&);
+};
+
+}
+
+class ModuleDelayJoin 
+	: public Module
+	, public CTCTags::EventListener
+	, public Names::EventListener
+{
+ public:
+	LocalIntExt unjoined;
+	JoinHook joinhook;
+	DelayJoinMode djm;
+
+	ModuleDelayJoin()
+		: CTCTags::EventListener(this)
+		, Names::EventListener(this)
+		, unjoined("delayjoin", ExtensionItem::EXT_MEMBERSHIP, this)
+		, joinhook(this, unjoined)
+		, djm(this, unjoined)
+	{
+	}
+
+	Version GetVersion() CXX11_OVERRIDE;
+	ModResult OnNamesListItem(LocalUser* issuer, Membership*, std::string& prefixes, std::string& nick) CXX11_OVERRIDE;
+	void OnUserJoin(Membership*, bool, bool, CUList&) CXX11_OVERRIDE;
 	void CleanUser(User* user);
-	void OnUserPart(Membership*, std::string &partmessage, CUList&);
-	void OnUserKick(User* source, Membership*, const std::string &reason, CUList&);
-	void OnBuildNeighborList(User* source, UserChanList &include, std::map<User*,bool> &exception);
-	void OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list);
-	ModResult OnRawMode(User* user, Channel* channel, const char mode, const std::string &param, bool adding, int pcnt);
+	void OnUserPart(Membership*, std::string &partmessage, CUList&) CXX11_OVERRIDE;
+	void OnUserKick(User* source, Membership*, const std::string &reason, CUList&) CXX11_OVERRIDE;
+	void OnBuildNeighborList(User* source, IncludeChanList& include, std::map<User*, bool>& exception) CXX11_OVERRIDE;
+	void OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details) CXX11_OVERRIDE;
+	void OnUserTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details) CXX11_OVERRIDE;
+	ModResult OnRawMode(User* user, Channel* channel, ModeHandler* mh, const std::string& param, bool adding) CXX11_OVERRIDE;
 };
 
 ModeAction DelayJoinMode::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 {
 	/* no change */
-	if (channel->IsModeSet('D') == adding)
+	if (channel->IsModeSet(this) == adding)
 		return MODEACTION_DENY;
 
 	if (!adding)
@@ -78,38 +117,36 @@ ModeAction DelayJoinMode::OnModeChange(User* source, User* dest, Channel* channe
 		 * Make all users visible, as +D is being removed. If we don't do this,
 		 * they remain permanently invisible on this channel!
 		 */
-		const UserMembList* names = channel->GetUsers();
-		for (UserMembCIter n = names->begin(); n != names->end(); ++n)
-			creator->OnText(n->first, channel, TYPE_CHANNEL, "", 0, empty);
+		const Channel::MemberMap& users = channel->GetUsers();
+		for (Channel::MemberMap::const_iterator n = users.begin(); n != users.end(); ++n)
+			RevealUser(n->first, channel);
 	}
-	channel->SetMode('D', adding);
+	channel->SetMode(this, adding);
 	return MODEACTION_ALLOW;
 }
 
-ModuleDelayJoin::~ModuleDelayJoin()
-{
-}
-
 Version ModuleDelayJoin::GetVersion()
 {
-	return Version("Allows for delay-join channels (+D) where users don't appear to join until they speak", VF_VENDOR);
+	return Version("Provides channel mode +D, delay-join, users don't appear as joined to others until they speak", VF_VENDOR);
 }
 
-void ModuleDelayJoin::OnNamesListItem(User* issuer, Membership* memb, std::string &prefixes, std::string &nick)
+ModResult ModuleDelayJoin::OnNamesListItem(LocalUser* issuer, Membership* memb, std::string& prefixes, std::string& nick)
 {
 	/* don't prevent the user from seeing themself */
 	if (issuer == memb->user)
-		return;
+		return MOD_RES_PASSTHRU;
 
 	/* If the user is hidden by delayed join, hide them from the NAMES list */
 	if (unjoined.get(memb))
-		nick.clear();
+		return MOD_RES_DENY;
+
+	return MOD_RES_PASSTHRU;
 }
 
 static void populate(CUList& except, Membership* memb)
 {
-	const UserMembList* users = memb->chan->GetUsers();
-	for(UserMembCIter i = users->begin(); i != users->end(); i++)
+	const Channel::MemberMap& users = memb->chan->GetUsers();
+	for (Channel::MemberMap::const_iterator i = users.begin(); i != users.end(); ++i)
 	{
 		if (i->first == memb->user || !IS_LOCAL(i->first))
 			continue;
@@ -119,11 +156,8 @@ static void populate(CUList& except, Membership* memb)
 
 void ModuleDelayJoin::OnUserJoin(Membership* memb, bool sync, bool created, CUList& except)
 {
-	if (memb->chan->IsModeSet('D'))
-	{
+	if (memb->chan->IsModeSet(djm))
 		unjoined.set(memb, 1);
-		populate(except, memb);
-	}
 }
 
 void ModuleDelayJoin::OnUserPart(Membership* memb, std::string &partmessage, CUList& except)
@@ -138,53 +172,57 @@ void ModuleDelayJoin::OnUserKick(User* source, Membership* memb, const std::stri
 		populate(except, memb);
 }
 
-void ModuleDelayJoin::OnBuildNeighborList(User* source, UserChanList &include, std::map<User*,bool> &exception)
+void ModuleDelayJoin::OnBuildNeighborList(User* source, IncludeChanList& include, std::map<User*, bool>& exception)
 {
-	UCListIter i = include.begin();
-	while (i != include.end())
+	for (IncludeChanList::iterator i = include.begin(); i != include.end(); )
 	{
-		Channel* c = *i++;
-		Membership* memb = c->GetUser(source);
-		if (memb && unjoined.get(memb))
-			include.erase(c);
+		Membership* memb = *i;
+		if (unjoined.get(memb))
+			i = include.erase(i);
+		else
+			++i;
 	}
 }
 
-void ModuleDelayJoin::OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list)
+void ModuleDelayJoin::OnUserTagMessage(User* user, const MessageTarget& target, const CTCTags::TagMessageDetails& details)
 {
-	/* Server origin */
-	if (!user)
+	if (target.type != MessageTarget::TYPE_CHANNEL)
 		return;
 
-	if (target_type != TYPE_CHANNEL)
+	Channel* channel = target.Get<Channel>();
+	djm.RevealUser(user, channel);
+}
+
+void ModuleDelayJoin::OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details)
+{
+	if (target.type != MessageTarget::TYPE_CHANNEL)
 		return;
 
-	Channel* channel = static_cast<Channel*>(dest);
+	Channel* channel = target.Get<Channel>();
+	djm.RevealUser(user, channel);
+}
 
-	Membership* memb = channel->GetUser(user);
+void DelayJoinMode::RevealUser(User* user, Channel* chan)
+{
+	Membership* memb = chan->GetUser(user);
 	if (!memb || !unjoined.set(memb, 0))
 		return;
 
 	/* Display the join to everyone else (the user who joined got it earlier) */
-	channel->WriteAllExceptSender(user, false, 0, "JOIN %s", channel->name.c_str());
-
-	std::string ms = memb->modes;
-	for(unsigned int i=0; i < memb->modes.length(); i++)
-		ms.append(" ").append(user->nick);
-
-	if (ms.length() > 0)
-		channel->WriteAllExceptSender(user, false, 0, "MODE %s +%s", channel->name.c_str(), ms.c_str());
+	CUList except_list;
+	except_list.insert(user);
+	ClientProtocol::Events::Join joinevent(memb);
+	chan->Write(joinevent, 0, except_list);
 }
 
 /* make the user visible if he receives any mode change */
-ModResult ModuleDelayJoin::OnRawMode(User* user, Channel* channel, const char mode, const std::string &param, bool adding, int pcnt)
+ModResult ModuleDelayJoin::OnRawMode(User* user, Channel* channel, ModeHandler* mh, const std::string& param, bool adding)
 {
-	if (!user || !channel || param.empty())
+	if (!channel || param.empty())
 		return MOD_RES_PASSTHRU;
 
-	ModeHandler* mh = ServerInstance->Modes->FindMode(mode, MODETYPE_CHANNEL);
 	// If not a prefix mode then we got nothing to do here
-	if (!mh || !mh->GetPrefixRank())
+	if (!mh->IsPrefixMode())
 		return MOD_RES_PASSTHRU;
 
 	User* dest;
@@ -196,9 +234,7 @@ ModResult ModuleDelayJoin::OnRawMode(User* user, Channel* channel, const char mo
 	if (!dest)
 		return MOD_RES_PASSTHRU;
 
-	Membership* memb = channel->GetUser(dest);
-	if (memb && unjoined.set(memb, 0))
-		channel->WriteAllExceptSender(dest, false, 0, "JOIN %s", channel->name.c_str());
+	djm.RevealUser(dest, channel);
 	return MOD_RES_PASSTHRU;
 }