Save ourselves 3 dereferences

[user/henk/code/inspircd.git] / src / mode.cpp

diff --git a/src/mode.cpp b/src/mode.cpp
index 0fe00f87dddc45ff6f15db2b3aea63dfc5368fba..5df98d23b0dae380e0d8b93199ffa47b00ee6aae 100644 (file)
--- a/src/mode.cpp
+++ b/src/mode.cpp
@@ -23,11 +23,7 @@ using namespace std;
 #include <sys/errno.h>
 #include <time.h>
 #include <string>
-#ifdef GCC3
-#include <ext/hash_map>
-#else
-#include <hash_map>
-#endif
+#include "hash_map.h"
 #include <map>
 #include <sstream>
 #include <vector>
@@ -46,9 +42,14 @@ using namespace std;
 #include "helperfuncs.h"
 #include "mode.h"
 
+/* +s (secret) */
 #include "modes/cmode_s.h"
+/* +p (private) */
 #include "modes/cmode_p.h"
+/* +b (bans) */
 #include "modes/cmode_b.h"
+/* +m (moderated) */
+#include "modes/cmode_m.h"
 
 extern int MODCOUNT;
 extern std::vector<Module*> modules;
@@ -58,7 +59,8 @@ extern ServerConfig* Config;
 
 extern time_t TIME;
 
-ModeHandler::ModeHandler(char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly) : mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), oper(operonly)
+ModeHandler::ModeHandler(char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly)
+       : mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), oper(operonly)
 {
 }
 
@@ -421,12 +423,14 @@ void ModeParser::Process(char **parameters, int pcnt, userrec *user, bool server
                int handler_id = 0;
                int parameter_counter = 2; /* Index of first parameter */
 
-               for (std::string::const_iterator modeletter = mode_sequence.begin(); modeletter != mode_sequence.end(); modeletter++)
+               for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
                {
-                       switch (*modeletter)
+                       unsigned char modechar = *letter;
+
+                       switch (modechar)
                        {
 
-                               log(DEBUG,"Iterate mode letter %c",*modeletter);
+                               log(DEBUG,"Iterate mode letter %c",modechar);
 
                                /* NB:
                                 * For + and - mode characters, we don't just stick the character into the output sequence.
@@ -461,13 +465,13 @@ void ModeParser::Process(char **parameters, int pcnt, userrec *user, bool server
                                         * a user mode. This is a little stranger, but a lot
                                         * faster, than using a map of pairs.
                                         */
-                                       handler_id = (*modeletter - 65) | mask;
+                                       handler_id = (modechar - 65) | mask;
 
                                        if (modehandlers[handler_id])
                                        {
                                                bool abort = false;
 
-                                               log(DEBUG,"Found a ModeHandler* for mode %c",*modeletter);
+                                               log(DEBUG,"Found a ModeHandler* for mode %c",modechar);
 
                                                for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
                                                {
@@ -481,18 +485,29 @@ void ModeParser::Process(char **parameters, int pcnt, userrec *user, bool server
 
                                                        if (modehandlers[handler_id]->GetNumParams(adding))
                                                        {
-                                                               log(DEBUG,"ModeHandler* for this mode says it has parameters");
+                                                               log(DEBUG,"ModeHandler* for this mode says it has parameters. pcnt=%d parameter_counter=%d",pcnt,parameter_counter);
 
-                                                               if (pcnt < parameter_counter)
+                                                               if (parameter_counter < pcnt)
                                                                {
                                                                        parameter = parameters[parameter_counter++];
                                                                }
                                                                else
                                                                {
-                                                                       parameter = "";
+                                                                       /* No parameter, continue to the next mode */
+                                                                       continue;
                                                                }
                                                        }
                                                        ModeAction ma = modehandlers[handler_id]->OnModeChange(user, targetuser, targetchannel, parameter, adding);
+
+                                                       if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter == ""))
+                                                       {
+                                                               /* The handler nuked the parameter and they are supposed to have one.
+                                                                * We CANT continue now, even if they actually returned MODEACTION_ALLOW,
+                                                                * so we bail to the next mode character.
+                                                                */
+                                                               continue;
+                                                       }
+
                                                        if (ma == MODEACTION_ALLOW)
                                                        {
                                                                log(DEBUG,"ModeAction was allow");
@@ -505,7 +520,7 @@ void ModeParser::Process(char **parameters, int pcnt, userrec *user, bool server
                                                                }
                                                                
                                                                /* Add the mode letter */
-                                                               output_sequence = output_sequence + *modeletter;
+                                                               output_sequence.push_back(modechar);
                                                                log(DEBUG,"Added mode letter to output sequence, sequence now: '%s'",output_sequence.c_str());
 
                                                                /* Is there a valid parameter for this mode? If so add it to the parameter list */
@@ -564,6 +579,39 @@ void cmd_mode::Handle (char **parameters, int pcnt, userrec *user)
        return;
 }
 
+void ModeParser::CleanMask(std::string &mask)
+{
+       std::string::size_type pos_of_pling = mask.find_first_of('!');
+       std::string::size_type pos_of_at = mask.find_first_of('@');
+       std::string::size_type pos_of_dot = mask.find_first_of('.');
+       std::string::size_type pos_of_colon = mask.find_first_of(':'); /* Because ipv6 addresses are colon delimited */
+
+       if ((pos_of_pling == std::string::npos) && (pos_of_at == std::string::npos))
+       {
+               /* Just a nick, or just a host */
+               if ((pos_of_dot == std::string::npos) && (pos_of_colon == std::string::npos))
+               {
+                       /* It has no '.' in it, it must be a nick. */
+                       mask.append("!*@*");
+               }
+               else
+               {
+                       /* Got a dot in it? Has to be a host */
+                       mask = "*!*@" + mask;
+               }
+       }
+       else if ((pos_of_pling == std::string::npos) && (pos_of_at != std::string::npos))
+       {
+               /* Has an @ but no !, its a user@host */
+                mask = "*!" + mask;
+       }
+       else if ((pos_of_pling != std::string::npos) && (pos_of_at == std::string::npos))
+       {
+               /* Has a ! but no @, it must be a nick!ident */
+               mask.append("@*");
+       }
+}
+
 bool ModeParser::AddMode(ModeHandler* mh, unsigned const char modeletter)
 {
        unsigned char mask = 0;
@@ -583,6 +631,7 @@ bool ModeParser::AddMode(ModeHandler* mh, unsigned const char modeletter)
                return false;
 
        modehandlers[pos] = mh;
+       log(DEBUG,"ModeParser::AddMode: added mode %c",modeletter);
        return true;
 }
 
@@ -596,5 +645,6 @@ ModeParser::ModeParser()
        this->AddMode(new ModeChannelSecret, 's');
        this->AddMode(new ModeChannelPrivate, 'p');
        this->AddMode(new ModeChannelBan, 'b');
+       this->AddMode(new ModeChannelModerated, 'm');
 }