]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/modules/m_override.cpp
Remove UserManager::GarbageCollect()
[user/henk/code/inspircd.git] / src / modules / m_override.cpp
index e342e7dab2dffd92ded0ca0eafddf7114260e726..8bf1d30792f01a9a136d3caa3abc96f5581dc3de 100644 (file)
@@ -25,6 +25,7 @@
 
 
 #include "inspircd.h"
+#include "modules/invite.h"
 
 class ModuleOverride : public Module
 {
@@ -34,6 +35,33 @@ class ModuleOverride : public Module
        ChanModeReference inviteonly;
        ChanModeReference key;
        ChanModeReference limit;
+       Invite::API invapi;
+
+       static bool IsOverride(unsigned int userlevel, const Modes::ChangeList::List& list)
+       {
+               for (Modes::ChangeList::List::const_iterator i = list.begin(); i != list.end(); ++i)
+               {
+                       ModeHandler* mh = i->mh;
+                       if (mh->GetLevelRequired() > userlevel)
+                               return true;
+               }
+               return false;
+       }
+
+       ModResult HandleJoinOverride(LocalUser* user, Channel* chan, const std::string& keygiven, const char* bypasswhat, const char* mode)
+       {
+               if (RequireKey && keygiven != "override")
+               {
+                       // Can't join normally -- must use a special key to bypass restrictions
+                       user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override.");
+                       return MOD_RES_PASSTHRU;
+               }
+
+               if (NoisyOverride)
+                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass %s", chan->name.c_str(), user->nick.c_str(), bypasswhat);
+               ServerInstance->SNO->WriteGlobalSno('v', user->nick+" used oper override to bypass " + mode + " on " + chan->name);
+               return MOD_RES_ALLOW;
+       }
 
  public:
        ModuleOverride()
@@ -41,19 +69,18 @@ class ModuleOverride : public Module
                , inviteonly(this, "inviteonly")
                , key(this, "key")
                , limit(this, "limit")
+               , invapi(this)
        {
        }
 
        void init() CXX11_OVERRIDE
        {
-               // read our config options (main config file)
-               OnRehash(NULL);
                ServerInstance->SNO->EnableSnomask('v', "OVERRIDE");
        }
 
-       void OnRehash(User* user) CXX11_OVERRIDE
+       void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
        {
-               // re-read our config options on a rehash
+               // re-read our config options
                ConfigTag* tag = ServerInstance->Config->ConfValue("override");
                NoisyOverride = tag->getBool("noisy");
                RequireKey = tag->getBool("requirekey");
@@ -103,20 +130,42 @@ class ModuleOverride : public Module
                return MOD_RES_PASSTHRU;
        }
 
-       ModResult OnPreMode(User* source,User* dest,Channel* channel, const std::vector<std::string>& parameters) CXX11_OVERRIDE
+       ModResult OnPreMode(User* source, User* dest, Channel* channel, Modes::ChangeList& modes) CXX11_OVERRIDE
        {
-               if (!source || !channel)
+               if (!channel)
                        return MOD_RES_PASSTHRU;
                if (!source->IsOper() || !IS_LOCAL(source))
                        return MOD_RES_PASSTHRU;
 
+               const Modes::ChangeList::List& list = modes.getlist();
                unsigned int mode = channel->GetPrefixValue(source);
 
-               if (mode < HALFOP_VALUE && CanOverride(source, "MODE"))
+               if (!IsOverride(mode, list))
+                       return MOD_RES_PASSTHRU;
+
+               if (CanOverride(source, "MODE"))
                {
-                       std::string msg = source->nick+" overriding modes:";
-                       for(unsigned int i=0; i < parameters.size(); i++)
-                               msg += " " + parameters[i];
+                       std::string msg = source->nick + " overriding modes: ";
+
+                       // Construct a MODE string in the old format for sending it as a snotice
+                       std::string params;
+                       char pm = 0;
+                       for (Modes::ChangeList::List::const_iterator i = list.begin(); i != list.end(); ++i)
+                       {
+                               const Modes::Change& item = *i;
+                               if (!item.param.empty())
+                                       params.append(1, ' ').append(item.param);
+
+                               char wanted_pm = (item.adding ? '+' : '-');
+                               if (wanted_pm != pm)
+                               {
+                                       pm = wanted_pm;
+                                       msg += pm;
+                               }
+
+                               msg += item.mh->GetModeChar();
+                       }
+                       msg += params;
                        ServerInstance->SNO->WriteGlobalSno('v',msg);
                        return MOD_RES_ALLOW;
                }
@@ -131,66 +180,19 @@ class ModuleOverride : public Module
                        {
                                if (chan->IsModeSet(inviteonly) && (CanOverride(user,"INVITE")))
                                {
-                                       if (!IS_LOCAL(user)->IsInvited(chan))
-                                       {
-                                               if (RequireKey && keygiven != "override")
-                                               {
-                                                       // Can't join normally -- must use a special key to bypass restrictions
-                                                       user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override.");
-                                                       return MOD_RES_PASSTHRU;
-                                               }
-
-                                               if (NoisyOverride)
-                                                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass invite-only", cname.c_str(), user->nick.c_str());
-                                               ServerInstance->SNO->WriteGlobalSno('v', user->nick+" used oper override to bypass +i on " + cname);
-                                       }
+                                       if (!invapi->IsInvited(user, chan))
+                                               return HandleJoinOverride(user, chan, keygiven, "invite-only", "+i");
                                        return MOD_RES_ALLOW;
                                }
 
                                if (chan->IsModeSet(key) && (CanOverride(user,"KEY")) && keygiven != chan->GetModeParameter(key))
-                               {
-                                       if (RequireKey && keygiven != "override")
-                                       {
-                                               // Can't join normally -- must use a special key to bypass restrictions
-                                               user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override.");
-                                               return MOD_RES_PASSTHRU;
-                                       }
-
-                                       if (NoisyOverride)
-                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass the channel key", cname.c_str(), user->nick.c_str());
-                                       ServerInstance->SNO->WriteGlobalSno('v', user->nick+" used oper override to bypass +k on " + cname);
-                                       return MOD_RES_ALLOW;
-                               }
+                                       return HandleJoinOverride(user, chan, keygiven, "the channel key", "+k");
 
                                if (chan->IsModeSet(limit) && (chan->GetUserCounter() >= ConvToInt(chan->GetModeParameter(limit))) && (CanOverride(user,"LIMIT")))
-                               {
-                                       if (RequireKey && keygiven != "override")
-                                       {
-                                               // Can't join normally -- must use a special key to bypass restrictions
-                                               user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override.");
-                                               return MOD_RES_PASSTHRU;
-                                       }
-
-                                       if (NoisyOverride)
-                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass the channel limit", cname.c_str(), user->nick.c_str());
-                                       ServerInstance->SNO->WriteGlobalSno('v', user->nick+" used oper override to bypass +l on " + cname);
-                                       return MOD_RES_ALLOW;
-                               }
+                                       return HandleJoinOverride(user, chan, keygiven, "the channel limit", "+l");
 
                                if (chan->IsBanned(user) && CanOverride(user,"BANWALK"))
-                               {
-                                       if (RequireKey && keygiven != "override")
-                                       {
-                                               // Can't join normally -- must use a special key to bypass restrictions
-                                               user->WriteNotice("*** You may not join normally. You must join with a key of 'override' to oper override.");
-                                               return MOD_RES_PASSTHRU;
-                                       }
-
-                                       if (NoisyOverride)
-                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass channel ban", cname.c_str(), user->nick.c_str());
-                                       ServerInstance->SNO->WriteGlobalSno('v',"%s used oper override to bypass channel ban on %s", user->nick.c_str(), cname.c_str());
-                                       return MOD_RES_ALLOW;
-                               }
+                                       return HandleJoinOverride(user, chan, keygiven, "channel ban", "channel ban");
                        }
                }
                return MOD_RES_PASSTHRU;