]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/modules/m_chanprotect.cpp
Added m_nokicks and chanmode +Q
[user/henk/code/inspircd.git] / src / modules / m_chanprotect.cpp
index a6d6a8a9f9553c79176e2db825c66dabc4159c45..ce7680ad48c9b3a62bb59d894ca1765475f50f90 100644 (file)
@@ -18,8 +18,13 @@ class ModuleChanProtect : public Module
  
        ModuleChanProtect()
        {
+       
+               // here we initialise our module. Use new to create new instances of the required
+               // classes.
+               
                Srv = new Server;
                Conf = new ConfigReader;
+               
                // set up our modes. We're using listmodes and not normal extmodes here.
                // listmodes only need one parameter as everything else is assumed by the
                // nature of the mode thats being created.
@@ -27,17 +32,16 @@ class ModuleChanProtect : public Module
                Srv->AddExtendedListMode('q');
                
                // read our config options (main config file)
-               std::string val = Conf->ReadValue("options","noservices",0);
-               FirstInGetsFounder = ((val == "yes") || (val == "1") || (val == "true"));
+               FirstInGetsFounder = Conf->ReadFlag("options","noservices",0);
        }
        
        virtual void OnRehash()
        {
+               // on a rehash we delete our classes for good measure and create them again.
                delete Conf;
                Conf = new ConfigReader;
                // re-read our config options on a rehash
-               std::string val = Conf->ReadValue("options","noservices",0);
-               FirstInGetsFounder = ((val == "yes") || (val == "1") || (val == "true"));
+               FirstInGetsFounder = Conf->ReadFlag("options","noservices",0);
        }
        
        virtual void OnUserJoin(userrec* user, chanrec* channel)
@@ -48,6 +52,10 @@ class ModuleChanProtect : public Module
                {
                        if (Srv->CountUsers(channel) == 1)
                        {
+                               // we're using Extensible::Extend to add data into user objects.
+                               // this way is best as it adds data thats accessible to other modules
+                               // (so long as you document your code properly) without breaking anything
+                               // because its encapsulated neatly in a map.
                                if (user->Extend("cm_founder_"+std::string(channel->name),dummyvalue))
                                {
                                        Srv->Log(DEBUG,"Marked user "+std::string(user->nick)+" as founder for "+std::string(channel->name));
@@ -58,71 +66,84 @@ class ModuleChanProtect : public Module
        
        virtual int OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type)
        {
+               // here we perform access checks, this is the important bit that actually stops kicking/deopping
+               // etc of protected users. There are many types of access check, we're going to handle
+               // a relatively small number of them relevent to our module using a switch statement.
+       
                // don't allow action if:
                // (A) Theyre founder (no matter what)
                // (B) Theyre protected, and you're not
                // always allow the action if:
                // (A) The source is ulined
                
-               if ((Srv->IsUlined(source->nick)) || (Srv->IsUlined(source->server)))
+               
+               // firstly, if a ulined nick, or a server, is setting the mode, then allow them to set the mode
+               // without any access checks, we're not worthy :p
+               if ((Srv->IsUlined(source->nick)) || (Srv->IsUlined(source->server)) || (!strcmp(source->server,"")))
                {
                        return ACR_ALLOW;
                }
 
                switch (access_type)
                {
+                       // a user has been deopped. Do we let them? hmmm...
                        case AC_DEOP:
                                if (dest->GetExt("cm_founder_"+std::string(channel->name)))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't deop "+std::string(dest->nick)+" as the're a channel founder");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't deop "+std::string(dest->nick)+" as the're a channel founder");
                                        return ACR_DENY;
                                }
                                if ((dest->GetExt("cm_protect_"+std::string(channel->name))) && (!source->GetExt("cm_protect_"+std::string(channel->name))))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't deop "+std::string(dest->nick)+" as the're protected (+a)");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't deop "+std::string(dest->nick)+" as the're protected (+a)");
                                        return ACR_DENY;
                                }
                        break;
 
+                       // a user is being kicked. do we chop off the end of the army boot?
                        case AC_KICK:
                                if (dest->GetExt("cm_founder_"+std::string(channel->name)))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't kick "+std::string(dest->nick)+" as the're a channel founder");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't kick "+std::string(dest->nick)+" as the're a channel founder");
                                        return ACR_DENY;
                                }
                                if ((dest->GetExt("cm_protect_"+std::string(channel->name))) && (!source->GetExt("cm_protect_"+std::string(channel->name))))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't kick "+std::string(dest->nick)+" as the're protected (+a)");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't kick "+std::string(dest->nick)+" as the're protected (+a)");
                                        return ACR_DENY;
                                }
                        break;
 
+                       // a user is being dehalfopped. Yes, we do disallow -h of a +ha user
                        case AC_DEHALFOP:
                                if (dest->GetExt("cm_founder_"+std::string(channel->name)))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't de-halfop "+std::string(dest->nick)+" as the're a channel founder");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't de-halfop "+std::string(dest->nick)+" as the're a channel founder");
                                        return ACR_DENY;
                                }
                                if ((dest->GetExt("cm_protect_"+std::string(channel->name))) && (!source->GetExt("cm_protect_"+std::string(channel->name))))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't de-halfop "+std::string(dest->nick)+" as the're protected (+a)");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't de-halfop "+std::string(dest->nick)+" as the're protected (+a)");
                                        return ACR_DENY;
                                }
                        break;
 
+                       // same with devoice.
                        case AC_DEVOICE:
                                if (dest->GetExt("cm_founder_"+std::string(channel->name)))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't devoice "+std::string(dest->nick)+" as the're a channel founder");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't devoice "+std::string(dest->nick)+" as the're a channel founder");
                                        return ACR_DENY;
                                }
                                if ((dest->GetExt("cm_protect_"+std::string(channel->name))) && (!source->GetExt("cm_protect_"+std::string(channel->name))))
                                {
-                                       Srv->SendServ(source->fd,"482 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't devoice "+std::string(dest->nick)+" as the're protected (+a)");
+                                       Srv->SendServ(source->fd,"484 "+std::string(source->nick)+" "+std::string(channel->name)+" :Can't devoice "+std::string(dest->nick)+" as the're protected (+a)");
                                        return ACR_DENY;
                                }
                        break;
                }
+               
+               // we dont know what this access check is, or dont care. just carry on, nothing to see here.
                return ACR_DEFAULT;
        }
        
@@ -143,6 +164,7 @@ class ModuleChanProtect : public Module
                        if (!Srv->IsOnChannel(theuser,chan))
                                return -1;
                        
+                       // source is a server, or ulined, we'll let them +-q the user.
                        if ((Srv->IsUlined(user->nick)) || (Srv->IsUlined(user->server)) || (!strcmp(user->server,"")))
                        {
                                if (mode_on)
@@ -166,7 +188,8 @@ class ModuleChanProtect : public Module
                        }
                        else
                        {
-                               WriteServ(user->fd,"482 %s %s :Only servers may set channel mode +q",user->nick, chan->name);
+                               // whoops, someones being naughty!
+                               WriteServ(user->fd,"468 %s %s :Only servers may set channel mode +q",user->nick, chan->name);
                                return -1;
                        }
                }
@@ -183,12 +206,13 @@ class ModuleChanProtect : public Module
                        // given user isnt even on the channel, eat the mode change
                        if (!Srv->IsOnChannel(theuser,chan))
                                return -1;
-                       
+
+                       // source has +q, is a server, or ulined, we'll let them +-a the user.
                        if ((Srv->IsUlined(user->nick)) || (Srv->IsUlined(user->server)) || (!strcmp(user->server,"")) || (user->GetExt("cm_founder_"+std::string(chan->name))))
                        {
                                if (mode_on)
                                {
-                                       if (!theuser->GetExt("cm_founder_"+std::string(chan->name)))
+                                       if (!theuser->GetExt("cm_protect_"+std::string(chan->name)))
                                        {
                                                theuser->Extend("cm_protect_"+std::string(chan->name),dummyvalue);
                                                return 1;
@@ -196,7 +220,7 @@ class ModuleChanProtect : public Module
                                }
                                else
                                {
-                                       if (theuser->GetExt("cm_founder_"+std::string(chan->name)))
+                                       if (theuser->GetExt("cm_protect_"+std::string(chan->name)))
                                        {
                                                theuser->Shrink("cm_protect_"+std::string(chan->name));
                                                return 1;
@@ -207,6 +231,7 @@ class ModuleChanProtect : public Module
                        }
                        else
                        {
+                               // bzzzt, wrong answer!
                                WriteServ(user->fd,"482 %s %s :You are not a channel founder",user->nick, chan->name);
                                return -1;
                        }
@@ -225,8 +250,25 @@ class ModuleChanProtect : public Module
                return Version(1,0,0,0);
        }
        
-       virtual void OnUserConnect(userrec* user)
+       virtual string_list OnChannelSync(chanrec* chan)
        {
+               // this is called when the server is linking into a net and wants to sync channel data.
+               // we should send our mode changes for the channel here to ensure that other servers
+               // know whos +q/+a on the channel.
+               chanuserlist cl = Srv->GetUsers(chan);
+               string_list commands;
+               for (int i = 0; i < cl.size(); i++)
+               {
+                       if (cl[i]->GetExt("cm_founder_"+std::string(chan->name)))
+                       {
+                               commands.push_back("M "+std::string(chan->name)+" +q "+std::string(cl[i]->nick));
+                       }
+                       if (cl[i]->GetExt("cm_protect_"+std::string(chan->name)))
+                       {
+                               commands.push_back("M "+std::string(chan->name)+" +a "+std::string(cl[i]->nick));
+                       }
+               }
+               return commands;
        }
 
 };