Add support for blocking tag messages with the deaf mode.

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

diff --git a/src/modules/m_exemptchanops.cpp b/src/modules/m_exemptchanops.cpp
index a7f86cdb5440c25c6769b37a3688823f9d977eea..ba5b7696732abb2a31bf6bfce453a2b498ff997a 100644 (file)
--- a/src/modules/m_exemptchanops.cpp
+++ b/src/modules/m_exemptchanops.cpp
@@ -1,6 +1,10 @@
 /*
  * InspIRCd -- Internet Relay Chat Daemon
  *
+ *   Copyright (C) 2013-2015 Attila Molnar <attilamolnar@hush.com>
+ *   Copyright (C) 2013, 2017-2020 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
+ *   Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
  *
  * This file is part of InspIRCd.  InspIRCd is free software: you can
@@ -21,35 +25,86 @@
 #include "listmode.h"
 #include "modules/exemption.h"
 
-/** Handles channel mode +X
- */
+enum
+{
+       RPL_ENDOFEXEMPTIONLIST = 953,
+       RPL_EXEMPTIONLIST = 954
+};
+
 class ExemptChanOps : public ListModeBase
 {
  public:
        ExemptChanOps(Module* Creator)
-               : ListModeBase(Creator, "exemptchanops", 'X', "End of channel exemptchanops list", 954, 953, false)
+               : ListModeBase(Creator, "exemptchanops", 'X', "End of channel exemptchanops list", RPL_EXEMPTIONLIST, RPL_ENDOFEXEMPTIONLIST, false)
+       {
+               syntax = "<restriction>:<prefix>";
+       }
+
+       static PrefixMode* FindMode(const std::string& mode)
+       {
+               if (mode.length() == 1)
+                       return ServerInstance->Modes->FindPrefixMode(mode[0]);
+
+               ModeHandler* mh = ServerInstance->Modes->FindMode(mode, MODETYPE_CHANNEL);
+               return mh ? mh->IsPrefixMode() : NULL;
+       }
+
+       static bool ParseEntry(const std::string& entry, std::string& restriction, std::string& prefix)
+       {
+               // The entry must be in the format <restriction>:<prefix>.
+               std::string::size_type colon = entry.find(':');
+               if (colon == std::string::npos || colon == entry.length()-1)
+                       return false;
+
+               restriction.assign(entry, 0, colon);
+               prefix.assign(entry, colon + 1, std::string::npos);
+               return true;
+       }
+
+       ModResult AccessCheck(User* source, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE
        {
+               std::string restriction;
+               std::string prefix;
+               if (!ParseEntry(parameter, restriction, prefix))
+                       return MOD_RES_PASSTHRU;
+
+               PrefixMode* pm = FindMode(prefix);
+               if (!pm)
+                       return MOD_RES_PASSTHRU;
+
+               if (channel->GetPrefixValue(source) >= pm->GetLevelRequired(adding))
+                       return MOD_RES_PASSTHRU;
+
+               source->WriteNumeric(ERR_CHANOPRIVSNEEDED, channel->name, InspIRCd::Format("You must be able to %s mode %c (%s) to %s a restriction containing it",
+                       adding ? "set" : "unset", pm->GetModeChar(), pm->name.c_str(), adding ? "add" : "remove"));
+               return MOD_RES_DENY;
        }
 
        bool ValidateParam(User* user, Channel* chan, std::string& word) CXX11_OVERRIDE
        {
-               std::string::size_type p = word.find(':');
-               if (p == std::string::npos)
+               std::string restriction;
+               std::string prefix;
+               if (!ParseEntry(word, restriction, prefix))
                {
-                       user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, word, "Invalid exemptchanops entry, format is <restriction>:<prefix>"));
+                       user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, word));
                        return false;
                }
 
-               std::string restriction(word, 0, p);
                // If there is a '-' in the restriction string ignore it and everything after it
                // to support "auditorium-vis" and "auditorium-see" in m_auditorium
-               p = restriction.find('-');
-               if (p != std::string::npos)
-                       restriction.erase(p);
+               std::string::size_type dash = restriction.find('-');
+               if (dash != std::string::npos)
+                       restriction.erase(dash);
 
                if (!ServerInstance->Modes->FindMode(restriction, MODETYPE_CHANNEL))
                {
-                       user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, word, "Unknown restriction"));
+                       user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, word, "Unknown restriction."));
+                       return false;
+               }
+
+               if (prefix != "*" && !FindMode(prefix))
+               {
+                       user->WriteNumeric(Numerics::InvalidModeParameter(chan, this, word, "Unknown prefix mode."));
                        return false;
                }
 
@@ -67,15 +122,6 @@ class ExemptHandler : public CheckExemption::EventListener
        {
        }
 
-       PrefixMode* FindMode(const std::string& mid)
-       {
-               if (mid.length() == 1)
-                       return ServerInstance->Modes->FindPrefixMode(mid[0]);
-
-               ModeHandler* mh = ServerInstance->Modes->FindMode(mid, MODETYPE_CHANNEL);
-               return mh ? mh->IsPrefixMode() : NULL;
-       }
-
        ModResult OnCheckExemption(User* user, Channel* chan, const std::string& restriction) CXX11_OVERRIDE
        {
                unsigned int mypfx = chan->GetPrefixValue(user);
@@ -95,7 +141,7 @@ class ExemptHandler : public CheckExemption::EventListener
                        }
                }
 
-               PrefixMode* mh = FindMode(minmode);
+               PrefixMode* mh = ExemptChanOps::FindMode(minmode);
                if (mh && mypfx >= mh->GetPrefixRank())
                        return MOD_RES_ALLOW;
                if (mh || minmode == "*")
@@ -116,7 +162,7 @@ class ModuleExemptChanOps : public Module
 
        Version GetVersion() CXX11_OVERRIDE
        {
-               return Version("Provides the ability to allow channel operators to be exempt from certain modes.",VF_VENDOR);
+               return Version("Adds channel mode X (exemptchanops) which allows channel operators to grant exemptions to various channel-level restrictions.", VF_VENDOR);
        }
 
        void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE