Fix new millisec /map to compile on windows, by ifndef gettimeofday out reverting...

[user/henk/code/inspircd.git] / src / modules / m_filter.h

diff --git a/src/modules/m_filter.h b/src/modules/m_filter.h
index 4fc7cfff422e9f8587fd95471d1c5d7536dfa989..5e74177e5073ce59ccadd902c4d1074cd518a1c7 100644 (file)
--- a/src/modules/m_filter.h
+++ b/src/modules/m_filter.h
@@ -15,11 +15,10 @@
 
 enum FilterFlags
 {
-       FLAG_NOOPERS,
-       FLAG_PART,
-       FLAG_QUIT,
-       FLAG_PRIVMSG,
-       FLAG_NOTICE
+       FLAG_PART = 2,
+       FLAG_QUIT = 4,
+       FLAG_PRIVMSG = 8,
+       FLAG_NOTICE = 16
 };
 
 class FilterResult : public classbase
@@ -43,8 +42,9 @@ class FilterResult : public classbase
                this->FillFlags(flags);
        }
 
-       int FillFlags(const std::string &flags)
+       int FillFlags(const std::string &fl)
        {
+               flags = fl;
                flag_no_opers = flag_part_message = flag_quit_message = flag_privmsg = flag_notice = false;
                size_t x = 0;
 
@@ -99,7 +99,7 @@ class FilterBase : public Module
        virtual ~FilterBase();
        virtual void Implements(char* List);
        virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list);
-       virtual FilterResult* FilterMatch(const std::string &text, int flags) = 0;
+       virtual FilterResult* FilterMatch(userrec* user, const std::string &text, int flags) = 0;
        virtual bool DeleteFilter(const std::string &freeform) = 0;
        virtual void SyncFilters(Module* proto, void* opaque) = 0;
        virtual void SendFilter(Module* proto, void* opaque, FilterResult* iter);
@@ -113,6 +113,7 @@ class FilterBase : public Module
        virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata);
        virtual int OnStats(char symbol, userrec* user, string_list &results) = 0;
        virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line);
+       bool AppliesToMe(userrec* user, FilterResult* filter, int flags);
 };
 
 class cmd_filter : public command_t
@@ -205,6 +206,21 @@ class cmd_filter : public command_t
        }
 };
 
+bool FilterBase::AppliesToMe(userrec* user, FilterResult* filter, int flags)
+{
+       if ((filter->flag_no_opers) && IS_OPER(user))
+               return false;
+       if ((flags & FLAG_PRIVMSG) && (!filter->flag_privmsg))
+               return false;
+       if ((flags & FLAG_NOTICE) && (!filter->flag_notice))
+               return false;
+       if ((flags & FLAG_QUIT)   && (!filter->flag_quit_message))
+               return false;
+       if ((flags & FLAG_PART)   && (!filter->flag_part_message))
+               return false;
+       return true;
+}
+
 FilterBase::FilterBase(InspIRCd* Me, const std::string &source) : Module(Me)
 {
        filtcommand = new cmd_filter(this, Me, source);
@@ -235,7 +251,7 @@ int FilterBase::OnUserPreNotice(userrec* user,void* dest,int target_type, std::s
        if ((ServerInstance->ULine(user->server)) || (!IS_LOCAL(user)))
                return 0;
 
-       FilterResult* f = this->FilterMatch(text, flags);
+       FilterResult* f = this->FilterMatch(user, text, flags);
        if (f)
        {
                std::string target = "";
@@ -295,7 +311,7 @@ int FilterBase::OnPreCommand(const std::string &command, const char** parameters
                        checkline = parameters[0];
                        replacepoint = 0;
                        parting = false;
-                       flags |= FLAG_QUIT;
+                       flags = FLAG_QUIT;
                }
                else if (command == "PART")
                {
@@ -306,7 +322,7 @@ int FilterBase::OnPreCommand(const std::string &command, const char** parameters
                        checkline = parameters[1];
                        replacepoint = 1;
                        parting = true;
-                       flags |= FLAG_PART;
+                       flags = FLAG_PART;
                }
                else
                        /* We're only messing with PART and QUIT */
@@ -315,7 +331,7 @@ int FilterBase::OnPreCommand(const std::string &command, const char** parameters
                FilterResult* f = NULL;
                
                if (flags)
-                       f = this->FilterMatch(checkline, flags);
+                       f = this->FilterMatch(user, checkline, flags);
 
                if (!f)
                        /* PART or QUIT reason doesnt match a filter */
@@ -325,7 +341,7 @@ int FilterBase::OnPreCommand(const std::string &command, const char** parameters
                command_t* c = ServerInstance->Parser->GetHandler(command);
                if (c)
                {
-                       const char* params[127];
+                       const char* params[MAXPARAMETERS];
                        for (int item = 0; item < pcnt; item++)
                                params[item] = parameters[item];
                        params[replacepoint] = "Reason filtered";
@@ -343,12 +359,8 @@ int FilterBase::OnPreCommand(const std::string &command, const char** parameters
                                /* Are they parting, if so, kill is applicable */
                                if ((parting) && (f->action == "kill"))
                                {
-                                       user->SetWriteError("Filtered: "+f->reason);
-                                       /* This WriteServ causes the write error to be applied.
-                                        * Its not safe to kill here with QuitUser in a PreCommand handler,
-                                        * so we do it this way, which is safe just about anywhere.
-                                        */
                                        user->WriteServ("NOTICE %s :*** Your PART message was filtered: %s", user->nick, f->reason.c_str());
+                                       userrec::QuitUser(ServerInstance, user, "Filtered: " + f->reason);
                                }
                                if (f->action == "gline")
                                {
@@ -385,28 +397,29 @@ std::string FilterBase::EncodeFilter(FilterResult* filter)
        std::ostringstream stream;
        std::string x = filter->freeform;
 
+       /* Hax to allow spaces in the freeform without changing the design of the irc protocol */
        for (std::string::iterator n = x.begin(); n != x.end(); n++)
                if (*n == ' ')
                        *n = '\7';
 
-       stream << x << " " << filter->action << " " << (filter->flags.empty() ? "-" : filter->flags) << " " << filter->gline_time << " " << filter->reason;
+       stream << x << " " << filter->action << " " << (filter->flags.empty() ? "-" : filter->flags) << " " << filter->gline_time << " :" << filter->reason;
        return stream.str();
 }
 
 FilterResult FilterBase::DecodeFilter(const std::string &data)
 {
        FilterResult res;
-       std::istringstream stream(data);
-
-       stream >> res.freeform;
-       stream >> res.action;
-       stream >> res.flags;
+       irc::tokenstream tokens(data);
+       tokens.GetToken(res.freeform);
+       tokens.GetToken(res.action);
+       tokens.GetToken(res.flags);
        if (res.flags == "-")
                res.flags = "";
        res.FillFlags(res.flags);
-       stream >> res.gline_time;
-       res.reason = stream.str();
+       tokens.GetToken(res.gline_time);
+       tokens.GetToken(res.reason);
 
+       /* Hax to allow spaces in the freeform without changing the design of the irc protocol */
        for (std::string::iterator n = res.freeform.begin(); n != res.freeform.end(); n++)
                if (*n == '\7')
                        *n = ' ';