Move checking for +ikl from the core to to core_channel.

[user/henk/code/inspircd.git] / src / coremods / core_channel / core_channel.cpp

diff --git a/src/coremods/core_channel/core_channel.cpp b/src/coremods/core_channel/core_channel.cpp
index 6fe6199dbd7ff321225797a2989a0ff036f128af..a49f8492d7daa8140acb29bf3a813246c1335641 100644 (file)
--- a/src/coremods/core_channel/core_channel.cpp
+++ b/src/coremods/core_channel/core_channel.cpp
@@ -22,7 +22,7 @@
 #include "invite.h"
 #include "listmode.h"
 
-class CoreModChannel : public Module
+class CoreModChannel : public Module, public CheckExemption::EventListener
 {
        Invite::APIImpl invapi;
        CommandInvite cmdinvite;
@@ -31,6 +31,20 @@ class CoreModChannel : public Module
        CommandNames cmdnames;
        CommandTopic cmdtopic;
 
+       ModeChannelBan banmode;
+       SimpleChannelModeHandler inviteonlymode;
+       ModeChannelKey keymode;
+       ModeChannelLimit limitmode;
+       SimpleChannelModeHandler moderatedmode;
+       SimpleChannelModeHandler noextmsgmode;
+       ModeChannelOp opmode;
+       SimpleChannelModeHandler privatemode;
+       SimpleChannelModeHandler secretmode;
+       SimpleChannelModeHandler topiclockmode;
+       ModeChannelVoice voicemode;
+
+       insp::flat_map<std::string, char> exemptions;
+
        ModResult IsInvited(User* user, Channel* chan)
        {
                LocalUser* localuser = IS_LOCAL(user);
@@ -41,8 +55,24 @@ class CoreModChannel : public Module
 
  public:
        CoreModChannel()
-               : invapi(this)
-               , cmdinvite(this, invapi), cmdjoin(this), cmdkick(this), cmdnames(this), cmdtopic(this)
+               : CheckExemption::EventListener(this)
+               , invapi(this)
+               , cmdinvite(this, invapi)
+               , cmdjoin(this)
+               , cmdkick(this)
+               , cmdnames(this)
+               , cmdtopic(this)
+               , banmode(this)
+               , inviteonlymode(this, "inviteonly", 'i')
+               , keymode(this)
+               , limitmode(this)
+               , moderatedmode(this, "moderated", 'm')
+               , noextmsgmode(this, "noextmsg", 'n')
+               , opmode(this)
+               , privatemode(this, "private", 'p')
+               , secretmode(this, "secret", 's')
+               , topiclockmode(this, "topiclock", 't')
+               , voicemode(this)
        {
        }
 
@@ -57,10 +87,35 @@ class CoreModChannel : public Module
                        for (unsigned int i = 0; i < sizeof(events)/sizeof(Implementation); i++)
                                ServerInstance->Modules.Detach(events[i], this);
                }
+
+               std::string current;
+               irc::spacesepstream defaultstream(optionstag->getString("exemptchanops"));
+               insp::flat_map<std::string, char> exempts;
+               while (defaultstream.GetToken(current))
+               {
+                       std::string::size_type pos = current.find(':');
+                       if (pos == std::string::npos || (pos + 2) > current.size())
+                               throw ModuleException("Invalid exemptchanops value '" + current + "' at " + optionstag->getTagLocation());
+
+                       const std::string restriction = current.substr(0, pos);
+                       const char prefix = current[pos + 1];
+
+                       ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Exempting prefix %c from %s", prefix, restriction.c_str());
+                       exempts[restriction] = prefix;
+               }
+               exemptions.swap(exempts);
+
+               // In 2.0 we allowed limits of 0 to be set. This is non-standard behaviour
+               // and will be removed in the next major release.
+               limitmode.minlimit = optionstag->getBool("allowzerolimit", true) ? 0 : 1;
+
+               banmode.DoRehash();
        }
 
        void On005Numeric(std::map<std::string, std::string>& tokens) CXX11_OVERRIDE
        {
+               tokens["KEYLEN"] = ConvToStr(ModeChannelKey::maxkeylen);
+
                // Build a map of limits to their mode character.
                insp::flat_map<int, std::string> limits;
                const ModeParser::ListModeList& listmodes = ServerInstance->Modes->GetListModes();
@@ -83,6 +138,53 @@ class CoreModChannel : public Module
                }
        }
 
+       ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string&, std::string&, const std::string& keygiven) CXX11_OVERRIDE
+       {
+               if (!chan)
+                       return MOD_RES_PASSTHRU;
+
+               // Check whether the channel key is correct.
+               const std::string ckey = chan->GetModeParameter(&keymode);
+               if (!ckey.empty())
+               {
+                       ModResult MOD_RESULT;
+                       FIRST_MOD_RESULT(OnCheckKey, MOD_RESULT, (user, chan, keygiven));
+                       if (!MOD_RESULT.check(InspIRCd::TimingSafeCompare(ckey, keygiven)))
+                       {
+                               // If no key provided, or key is not the right one, and can't bypass +k (not invited or option not enabled)
+                               user->WriteNumeric(ERR_BADCHANNELKEY, chan->name, "Cannot join channel (Incorrect channel key)");
+                               return MOD_RES_DENY;
+                       }
+               }
+
+               // Check whether the invite only mode is set.
+               if (chan->IsModeSet(inviteonlymode))
+               {
+                       ModResult MOD_RESULT;
+                       FIRST_MOD_RESULT(OnCheckInvite, MOD_RESULT, (user, chan));
+                       if (MOD_RESULT != MOD_RES_ALLOW)
+                       {
+                               user->WriteNumeric(ERR_INVITEONLYCHAN, chan->name, "Cannot join channel (Invite only)");
+                               return MOD_RES_DENY;
+                       }
+               }
+
+               // Check whether the limit would be exceeded by this user joining.
+               if (chan->IsModeSet(limitmode))
+               {
+                       ModResult MOD_RESULT;
+                       FIRST_MOD_RESULT(OnCheckLimit, MOD_RESULT, (user, chan));
+                       if (!MOD_RESULT.check(chan->GetUserCounter() < static_cast<size_t>(limitmode.ext.get(chan))))
+                       {
+                               user->WriteNumeric(ERR_CHANNELISFULL, chan->name, "Cannot join channel (Channel is full)");
+                               return MOD_RES_DENY;
+                       }
+               }
+
+               // Everything looks okay.
+               return MOD_RES_PASSTHRU;
+       }
+
        void OnPostJoin(Membership* memb) CXX11_OVERRIDE
        {
                Channel* const chan = memb->chan;
@@ -92,7 +194,7 @@ class CoreModChannel : public Module
                        // Remove existing invite, if any
                        invapi.Remove(localuser, chan);
 
-                       if (chan->topicset)
+                       if (chan->topic.length())
                                Topic::ShowTopic(localuser, chan);
 
                        // Show all members of the channel, including invisible (+i) users
@@ -135,6 +237,22 @@ class CoreModChannel : public Module
                invapi.RemoveAll(chan);
        }
 
+       ModResult OnCheckExemption(User* user, Channel* chan, const std::string& restriction) CXX11_OVERRIDE
+       {
+               if (!exemptions.count(restriction))
+                       return MOD_RES_PASSTHRU;
+
+               unsigned int mypfx = chan->GetPrefixValue(user);
+               char minmode = exemptions[restriction];
+
+               PrefixMode* mh = ServerInstance->Modes->FindPrefixMode(minmode);
+               if (mh && mypfx >= mh->GetPrefixRank())
+                       return MOD_RES_ALLOW;
+               if (mh || minmode == '*')
+                       return MOD_RES_DENY;
+               return MOD_RES_PASSTHRU;
+       }
+
        void Prioritize() CXX11_OVERRIDE
        {
                ServerInstance->Modules.SetPriority(this, I_OnPostJoin, PRIORITY_FIRST);