Improvements and bugfixes to the cgiirc module.

[user/henk/code/inspircd.git] / src / modules / m_delayjoin.cpp

diff --git a/src/modules/m_delayjoin.cpp b/src/modules/m_delayjoin.cpp
index e864a8289c75e0f8d6be6b174fc7f33f4c65524c..d157b97bcc90461ebf39d3895aa031919a1d6b7c 100644 (file)
--- a/src/modules/m_delayjoin.cpp
+++ b/src/modules/m_delayjoin.cpp
@@ -24,24 +24,59 @@
 
 class DelayJoinMode : public ModeHandler
 {
-       CUList empty;
  public:
        DelayJoinMode(Module* Parent) : ModeHandler(Parent, "delayjoin", 'D', PARAM_NONE, MODETYPE_CHANNEL)
        {
-               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;
 };
 
+
+namespace
+{
+
+/** 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:
+       JoinHook(Module* mod, const LocalIntExt& unjoinedref)
+               : ClientProtocol::EventHook(mod, "JOIN", 10)
+               , unjoined(unjoinedref)
+       {
+       }
+
+       ModResult OnPreEventSend(LocalUser* user, const ClientProtocol::Event& ev, ClientProtocol::MessageList& messagelist) CXX11_OVERRIDE
+       {
+               const ClientProtocol::Events::Join& join = static_cast<const ClientProtocol::Events::Join&>(ev);
+               const User* const u = join.GetMember()->user;
+               if ((unjoined.get(u)) && (u != user))
+                       return MOD_RES_DENY;
+               return MOD_RES_PASSTHRU;
+       }
+};
+
+}
+
 class ModuleDelayJoin : public Module
 {
        DelayJoinMode djm;
+       void RevealUser(User* user, Channel* chan);
  public:
        LocalIntExt unjoined;
+       JoinHook joinhook;
+
        ModuleDelayJoin()
                : djm(this)
                , unjoined("delayjoin", ExtensionItem::EXT_MEMBERSHIP, this)
+               , joinhook(this, unjoined)
        {
        }
 
@@ -52,10 +87,20 @@ class ModuleDelayJoin : public Module
        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 OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list) CXX11_OVERRIDE;
+       void OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details) CXX11_OVERRIDE;
        ModResult OnRawMode(User* user, Channel* channel, ModeHandler* mh, const std::string& param, bool adding) CXX11_OVERRIDE;
 };
 
+// TODO: make RevealUser accessible from DelayJoinMode and get rid of this.
+class DummyMessageDetails : public MessageDetails
+{
+public:
+       DummyMessageDetails() : MessageDetails(MSG_PRIVMSG, "", ClientProtocol::TagMap()) { }
+       bool IsCTCP(std::string& name, std::string& body) const CXX11_OVERRIDE { return false; }
+       bool IsCTCP(std::string&) const CXX11_OVERRIDE { return false; }
+       bool IsCTCP() const CXX11_OVERRIDE { return false; }
+};
+
 ModeAction DelayJoinMode::OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
 {
        /* no change */
@@ -68,9 +113,13 @@ 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!
                 */
+               MessageTarget msgtarget(channel, 0);
+               DummyMessageDetails msgdetails;
                const Channel::MemberMap& users = channel->GetUsers();
                for (Channel::MemberMap::const_iterator n = users.begin(); n != users.end(); ++n)
-                       creator->OnText(n->first, channel, TYPE_CHANNEL, "", 0, empty);
+               {
+                       creator->OnUserMessage(n->first, msgtarget, msgdetails);
+               }
        }
        channel->SetMode(this, adding);
        return MODEACTION_ALLOW;
@@ -108,10 +157,7 @@ static void populate(CUList& except, Membership* memb)
 void ModuleDelayJoin::OnUserJoin(Membership* memb, bool sync, bool created, CUList& except)
 {
        if (memb->chan->IsModeSet(djm))
-       {
                unjoined.set(memb, 1);
-               populate(except, memb);
-       }
 }
 
 void ModuleDelayJoin::OnUserPart(Membership* memb, std::string &partmessage, CUList& except)
@@ -138,26 +184,26 @@ void ModuleDelayJoin::OnBuildNeighborList(User* source, IncludeChanList& include
        }
 }
 
-void ModuleDelayJoin::OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list)
+void ModuleDelayJoin::OnUserMessage(User* user, const MessageTarget& target, const MessageDetails& details)
 {
-       if (target_type != TYPE_CHANNEL)
+       if (target.type != MessageTarget::TYPE_CHANNEL)
                return;
 
-       Channel* channel = static_cast<Channel*>(dest);
+       Channel* channel = target.Get<Channel>();
+       RevealUser(user, channel);
+}
 
-       Membership* memb = channel->GetUser(user);
+void ModuleDelayJoin::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 */
@@ -179,9 +225,7 @@ ModResult ModuleDelayJoin::OnRawMode(User* user, Channel* channel, ModeHandler*
        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());
+       RevealUser(dest, channel);
        return MOD_RES_PASSTHRU;
 }