]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/modules/m_override.cpp
Fix various rline bugs, implement /stats R, and fix the issue where you get no error...
[user/henk/code/inspircd.git] / src / modules / m_override.cpp
index f4473e81d57397a58447471126ecb739c8d3bbed..859b7e7b7c78713ddae4ec666ab903f99b5e4124 100644 (file)
@@ -12,7 +12,6 @@
  */
 
 #include "inspircd.h"
-#include "wildcard.h"
 
 /* $ModDesc: Provides support for unreal-style oper-override */
 
@@ -20,46 +19,49 @@ typedef std::map<std::string,std::string> override_t;
 
 class ModuleOverride : public Module
 {
-       
        override_t overrides;
+       bool RequireKey;
        bool NoisyOverride;
        bool OverriddenMode;
        int OverOps, OverDeops, OverVoices, OverDevoices, OverHalfops, OverDehalfops;
 
  public:
+
        ModuleOverride(InspIRCd* Me)
                : Module(Me)
-       {               
+       {
                // read our config options (main config file)
                OnRehash(NULL,"");
-               ServerInstance->SNO->EnableSnomask('O',"OVERRIDE");
+               ServerInstance->SNO->EnableSnomask('O', "OVERRIDE");
                OverriddenMode = false;
                OverOps = OverDeops = OverVoices = OverDevoices = OverHalfops = OverDehalfops = 0;
-               Implementation eventlist[] = { I_OnRehash, I_OnAccessCheck, I_On005Numeric, I_OnUserPreJoin, I_OnUserPreKick, I_OnPostCommand };
-               ServerInstance->Modules->Attach(eventlist, this, 6);
+               Implementation eventlist[] = { I_OnRehash, I_OnAccessCheck, I_On005Numeric, I_OnUserPreJoin, I_OnUserPreKick, I_OnPostCommand, I_OnLocalTopicChange };
+               ServerInstance->Modules->Attach(eventlist, this, 7);
        }
-       
+
        virtual void OnRehash(User* user, const std::string &parameter)
        {
                // on a rehash we delete our classes for good measure and create them again.
                ConfigReader* Conf = new ConfigReader(ServerInstance);
-               
+
                // re-read our config options on a rehash
-               NoisyOverride = Conf->ReadFlag("override","noisy",0);
+               NoisyOverride = Conf->ReadFlag("override", "noisy", 0);
+               RequireKey = Conf->ReadFlag("override", "requirekey", 0);
+
                overrides.clear();
+
                for (int j =0; j < Conf->Enumerate("type"); j++)
                {
                        std::string typen = Conf->ReadValue("type","name",j);
                        std::string tokenlist = Conf->ReadValue("type","override",j);
                        overrides[typen] = tokenlist;
                }
-               
+
                delete Conf;
        }
 
 
-       virtual void OnPostCommand(const std::string &command, const char* const* parameters, int pcnt, User *user, CmdResult result, const std::string &original_line)
+       virtual void OnPostCommand(const std::string &command, const std::vector<std::string> &parameters, User *user, CmdResult result, const std::string &original_line)
        {
                if ((NoisyOverride) && (OverriddenMode) && (irc::string(command.c_str()) == "MODE") && (result == CMD_SUCCESS))
                {
@@ -99,20 +101,38 @@ class ModuleOverride : public Module
                return false;
        }
 
+
+       virtual int OnLocalTopicChange(User *source, Channel *channel, const std::string &topic)
+       {
+               if (IS_OPER(source) && CanOverride(source, "TOPIC"))
+               {
+                       if (!channel->HasUser(source) || (channel->IsModeSet('t') && channel->GetStatus(source) < STATUS_HOP))
+                       {
+                               ServerInstance->SNO->WriteToSnoMask('O',std::string(source->nick)+"  used oper override to change a topic on "+std::string(channel->name));
+                       }
+
+                       // Explicit allow
+                       return -1;
+               }
+
+               return 0;
+       }
+
        virtual int OnUserPreKick(User* source, User* user, Channel* chan, const std::string &reason)
        {
                if (IS_OPER(source) && CanOverride(source,"KICK"))
                {
-                       if (((chan->GetStatus(source) == STATUS_HOP) && (chan->GetStatus(user) == STATUS_OP)) || (chan->GetStatus(source) < STATUS_VOICE))
-                       {
-                               ServerInstance->SNO->WriteToSnoMask('O',std::string(source->nick)+" Override-Kicked "+std::string(user->nick)+" on "+std::string(chan->name)+" ("+reason+")");
+                       // If the kicker's status is less than the target's,                    or      the kicker's status is less than or equal to voice
+                       if ((chan->GetStatus(source) < chan->GetStatus(user))                   || (chan->GetStatus(source) <= STATUS_VOICE))
+                       {                               
+                               ServerInstance->SNO->WriteToSnoMask('O',std::string(source->nick)+" used oper override to kick "+std::string(user->nick)+" on "+std::string(chan->name)+" ("+reason+")");
                        }
                        /* Returning -1 explicitly allows the kick */
                        return -1;
                }
                return 0;
        }
-       
+
        virtual int OnAccessCheck(User* source,User* dest,Channel* channel,int access_type)
        {
                if (IS_OPER(source))
@@ -203,7 +223,7 @@ class ModuleOverride : public Module
                                                }
                                        break;
                                }
-                       
+
                                if (CanOverride(source,"OTHERMODE"))
                                {
                                        if (NoisyOverride)
@@ -223,39 +243,59 @@ class ModuleOverride : public Module
 
                return ACR_DEFAULT;
        }
-       
+
        virtual int OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string &privs, const std::string &keygiven)
        {
-               if (IS_OPER(user))
+               if (IS_LOCAL(user) && IS_OPER(user))
                {
                        if (chan)
                        {
                                if ((chan->modes[CM_INVITEONLY]) && (CanOverride(user,"INVITE")))
                                {
-                                       irc::string x = chan->name;
+                                       irc::string x(chan->name.c_str());
                                        if (!user->IsInvited(x))
                                        {
-                                               /* XXX - Ugly cast for a parameter that isn't used? :< - Om */
+                                               if (RequireKey && keygiven != "override")
+                                               {
+                                                       // Can't join normally -- must use a special key to bypass restrictions
+                                                       user->WriteServ("NOTICE %s :*** You may not join normally. You must join with a key of 'override' to oper override.", user->nick.c_str());
+                                                       return 1;
+                                               }
+
                                                if (NoisyOverride)
-                                                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper-override to bypass invite-only", cname, user->nick);
-                                               ServerInstance->SNO->WriteToSnoMask('O',std::string(user->nick)+" used operoverride to bypass +i on "+std::string(cname));
+                                                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass invite-only", cname, user->nick.c_str());
+                                               ServerInstance->SNO->WriteToSnoMask('O', user->nick+" used oper override to bypass +i on "+std::string(cname));
                                        }
                                        return -1;
                                }
-                               
-                               if ((*chan->key) && (CanOverride(user,"KEY")) && strcasecmp(keygiven.c_str(), chan->key))
+
+                               if ((chan->modes[CM_KEY]) && (CanOverride(user,"KEY")) && keygiven != chan->GetModeParameter('k'))
                                {
+                                       if (RequireKey && keygiven != "override")
+                                       {
+                                               // Can't join normally -- must use a special key to bypass restrictions
+                                               user->WriteServ("NOTICE %s :*** You may not join normally. You must join with a key of 'override' to oper override.", user->nick.c_str());
+                                               return 1;
+                                       }
+
                                        if (NoisyOverride)
-                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper-override to bypass the channel key", cname, user->nick);
-                                       ServerInstance->SNO->WriteToSnoMask('O',std::string(user->nick)+" used operoverride to bypass +k on "+std::string(cname));
+                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass the channel key", cname, user->nick.c_str());
+                                       ServerInstance->SNO->WriteToSnoMask('O', user->nick+" used oper override to bypass +k on "+std::string(cname));
                                        return -1;
                                }
-                                       
-                               if ((chan->limit > 0) && (chan->GetUserCounter() >=  chan->limit) && (CanOverride(user,"LIMIT")))
+
+                               if ((chan->modes[CM_LIMIT]) && (chan->GetUserCounter() >=  atoi(chan->GetModeParameter('l').c_str())) && (CanOverride(user,"LIMIT")))
                                {
+                                       if (RequireKey && keygiven != "override")
+                                       {
+                                               // Can't join normally -- must use a special key to bypass restrictions
+                                               user->WriteServ("NOTICE %s :*** You may not join normally. You must join with a key of 'override' to oper override.", user->nick.c_str());
+                                               return 1;
+                                       }
+
                                        if (NoisyOverride)
-                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper-override to bypass the channel limit", cname, user->nick);
-                                       ServerInstance->SNO->WriteToSnoMask('O',std::string(user->nick)+" used operoverride to bypass +l on "+std::string(cname));
+                                               chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass the channel limit", cname, user->nick.c_str());
+                                       ServerInstance->SNO->WriteToSnoMask('O', user->nick+" used oper override to bypass +l on "+std::string(cname));
                                        return -1;
                                }
 
@@ -263,9 +303,16 @@ class ModuleOverride : public Module
                                {
                                        if (chan->IsBanned(user))
                                        {
+                                               if (RequireKey && keygiven != "override")
+                                               {
+                                                       // Can't join normally -- must use a special key to bypass restrictions
+                                                       user->WriteServ("NOTICE %s :*** You may not join normally. You must join with a key of 'override' to oper override.", user->nick.c_str());
+                                                       return 1;
+                                               }
+
                                                if (NoisyOverride)
-                                                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper-override to bypass channel ban", cname, user->nick);
-                                               ServerInstance->SNO->WriteToSnoMask('O',"%s used oper-override to bypass channel ban on %s", user->nick, cname);
+                                                       chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :%s used oper override to bypass channel ban", cname, user->nick.c_str());
+                                               ServerInstance->SNO->WriteToSnoMask('O',"%s used oper override to bypass channel ban on %s", user->nick.c_str(), cname);
                                        }
                                        return -1;
                                }
@@ -273,15 +320,15 @@ class ModuleOverride : public Module
                }
                return 0;
        }
-       
+
        virtual ~ModuleOverride()
        {
                ServerInstance->SNO->DisableSnomask('O');
        }
-       
+
        virtual Version GetVersion()
        {
-               return Version(1,2,0,1,VF_VENDOR,API_VERSION);
+               return Version("$Id$",VF_VENDOR,API_VERSION);
        }
 };