X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_filter.cpp;h=a3e30ecb463f4137f3cdbb09051a3c4bf5791ede;hb=f9fd78c01623514a060c607534fc52cb73140200;hp=e4b2645f9b35ba950564f68bb0836deac8155c7b;hpb=7aab0d12db670fea68a258d9ae2b05ea5c4615be;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_filter.cpp b/src/modules/m_filter.cpp index e4b2645f9..a3e30ecb4 100644 --- a/src/modules/m_filter.cpp +++ b/src/modules/m_filter.cpp @@ -1,23 +1,28 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2010 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2004, 2008 Craig Edwards + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2007 Robin Burchell * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ + #include "inspircd.h" #include "xline.h" -#include "m_regex.h" - -/* $ModDesc: Text (spam) filtering */ - -class ModuleFilter; +#include "modules/regex.h" enum FilterFlags { @@ -27,34 +32,46 @@ enum FilterFlags FLAG_NOTICE = 16 }; +enum FilterAction +{ + FA_GLINE, + FA_BLOCK, + FA_SILENT, + FA_KILL, + FA_NONE +}; + class FilterResult { public: + Regex* regex; std::string freeform; std::string reason; - std::string action; + FilterAction action; long gline_time; - std::string flags; bool flag_no_opers; bool flag_part_message; bool flag_quit_message; bool flag_privmsg; bool flag_notice; + bool flag_strip_color; - FilterResult(const std::string free, const std::string &rea, const std::string &act, long gt, const std::string &fla) : - freeform(free), reason(rea), action(act), gline_time(gt), flags(fla) + FilterResult(dynamic_reference& RegexEngine, const std::string& free, const std::string& rea, FilterAction act, long gt, const std::string& fla) + : freeform(free), reason(rea), action(act), gline_time(gt) { + if (!RegexEngine) + throw ModuleException("Regex module implementing '"+RegexEngine.GetProvider()+"' is not loaded!"); + regex = RegexEngine->Create(free); this->FillFlags(fla); } - int FillFlags(const std::string &fl) + char 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; + flag_no_opers = flag_part_message = flag_quit_message = flag_privmsg = + flag_notice = flag_strip_color = false; - for (std::string::const_iterator n = flags.begin(); n != flags.end(); ++n, ++x) + for (std::string::const_iterator n = fl.begin(); n != fl.end(); ++n) { switch (*n) { @@ -73,23 +90,49 @@ class FilterResult case 'n': flag_notice = true; break; + case 'c': + flag_strip_color = true; + break; case '*': flag_no_opers = flag_part_message = flag_quit_message = - flag_privmsg = flag_notice = true; + flag_privmsg = flag_notice = flag_strip_color = true; break; default: - return x; + return *n; break; } } return 0; } - FilterResult() + std::string GetFlags() { + std::string flags; + if (flag_no_opers) + flags.push_back('o'); + if (flag_part_message) + flags.push_back('P'); + if (flag_quit_message) + flags.push_back('q'); + if (flag_privmsg) + flags.push_back('p'); + if (flag_notice) + flags.push_back('n'); + + /* Order is important here, 'c' must be the last char in the string as it is unsupported + * on < 2.0.10, and the logic in FillFlags() stops parsing when it ecounters an unknown + * character. + */ + if (flag_strip_color) + flags.push_back('c'); + + if (flags.empty()) + flags.push_back('-'); + + return flags; } - ~FilterResult() + FilterResult() { } }; @@ -105,59 +148,52 @@ class CommandFilter : public Command } CmdResult Handle(const std::vector&, User*); - void TooFewParams(User* user, const std::string &extra_text) - { - user->WriteServ("NOTICE %s :*** Not enough parameters%s", user->nick.c_str(), extra_text.c_str()); - } - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } }; -class ImplFilter : public FilterResult +class ModuleFilter : public Module { - public: - Regex* regex; - - ImplFilter(ModuleFilter* mymodule, const std::string &rea, const std::string &act, long glinetime, const std::string &pat, const std::string &flgs); -}; + typedef insp::flat_set ExemptTargetSet; + bool initing; + RegexFactory* factory; + void FreeFilters(); -class ModuleFilter : public Module -{ public: CommandFilter filtcommand; dynamic_reference RegexEngine; - std::vector filters; - const char *error; - int erroffset; + std::vector filters; int flags; - std::vector exemptfromfilter; // List of channel names excluded from filtering. + // List of channel names excluded from filtering. + ExemptTargetSet exemptedchans; + + // List of target nicknames excluded from filtering. + ExemptTargetSet exemptednicks; ModuleFilter(); - void init(); - ~ModuleFilter(); - ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list); + CullResult cull(); + ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE; FilterResult* FilterMatch(User* user, const std::string &text, int flags); bool DeleteFilter(const std::string &freeform); - void SyncFilters(Module* proto, void* opaque); - void SendFilter(Module* proto, void* opaque, FilterResult* iter); - std::pair AddFilter(const std::string &freeform, const std::string &type, const std::string &reason, long duration, const std::string &flags); - ModResult OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list); - void OnRehash(User* user); - Version GetVersion(); + std::pair AddFilter(const std::string &freeform, FilterAction type, const std::string &reason, long duration, const std::string &flags); + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE; + Version GetVersion() CXX11_OVERRIDE; std::string EncodeFilter(FilterResult* filter); FilterResult DecodeFilter(const std::string &data); - void OnSyncNetwork(Module* proto, void* opaque); - void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata); - ModResult OnStats(char symbol, User* user, string_list &results); - ModResult OnPreCommand(std::string &command, std::vector ¶meters, LocalUser *user, bool validated, const std::string &original_line); + void OnSyncNetwork(ProtocolInterface::Server& server) CXX11_OVERRIDE; + void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata) CXX11_OVERRIDE; + ModResult OnStats(Stats::Context& stats) CXX11_OVERRIDE; + ModResult OnPreCommand(std::string &command, std::vector ¶meters, LocalUser *user, bool validated, const std::string &original_line) CXX11_OVERRIDE; + void OnUnloadModule(Module* mod) CXX11_OVERRIDE; bool AppliesToMe(User* user, FilterResult* filter, int flags); - void ReadFilters(ConfigReader &MyConf); + void ReadFilters(); + static bool StringToFilterAction(const std::string& str, FilterAction& fa); + static std::string FilterActionToString(FilterAction fa); }; CmdResult CommandFilter::Handle(const std::vector ¶meters, User *user) @@ -168,13 +204,13 @@ CmdResult CommandFilter::Handle(const std::vector ¶meters, User Module *me = creator; if (static_cast(me)->DeleteFilter(parameters[0])) { - user->WriteServ("NOTICE %s :*** Removed filter '%s'", user->nick.c_str(), parameters[0].c_str()); - ServerInstance->SNO->WriteToSnoMask(IS_LOCAL(user) ? 'a' : 'A', std::string("FILTER: ")+user->nick+" removed filter '"+parameters[0]+"'"); + user->WriteNotice("*** Removed filter '" + parameters[0] + "'"); + ServerInstance->SNO->WriteToSnoMask(IS_LOCAL(user) ? 'a' : 'A', "FILTER: "+user->nick+" removed filter '"+parameters[0]+"'"); return CMD_SUCCESS; } else { - user->WriteServ("NOTICE %s :*** Filter '%s' not found in list, try /stats s.", user->nick.c_str(), parameters[0].c_str()); + user->WriteNotice("*** Filter '" + parameters[0] + "' not found in list, try /stats s."); return CMD_FAILURE; } } @@ -183,58 +219,57 @@ CmdResult CommandFilter::Handle(const std::vector ¶meters, User /* Adding a filter */ if (parameters.size() >= 4) { - std::string freeform = parameters[0]; - std::string type = parameters[1]; - std::string flags = parameters[2]; - std::string reason; + const std::string& freeform = parameters[0]; + FilterAction type; + const std::string& flags = parameters[2]; + unsigned int reasonindex; long duration = 0; - - if ((type != "gline") && (type != "none") && (type != "block") && (type != "kill") && (type != "silent")) + if (!ModuleFilter::StringToFilterAction(parameters[1], type)) { - user->WriteServ("NOTICE %s :*** Invalid filter type '%s'. Supported types are 'gline', 'none', 'block', 'silent' and 'kill'.", user->nick.c_str(), type.c_str()); + user->WriteNotice("*** Invalid filter type '" + parameters[1] + "'. Supported types are 'gline', 'none', 'block', 'silent' and 'kill'."); return CMD_FAILURE; } - if (type == "gline") + if (type == FA_GLINE) { if (parameters.size() >= 5) { - duration = ServerInstance->Duration(parameters[3]); - reason = parameters[4]; + duration = InspIRCd::Duration(parameters[3]); + reasonindex = 4; } else { - this->TooFewParams(user, ": When setting a gline type filter, a gline duration must be specified as the third parameter."); + user->WriteNotice("*** Not enough parameters: When setting a gline type filter, a gline duration must be specified as the third parameter."); return CMD_FAILURE; } } else { - reason = parameters[3]; + reasonindex = 3; } - + Module *me = creator; - std::pair result = static_cast(me)->AddFilter(freeform, type, reason, duration, flags); + std::pair result = static_cast(me)->AddFilter(freeform, type, parameters[reasonindex], duration, flags); if (result.first) { - user->WriteServ("NOTICE %s :*** Added filter '%s', type '%s'%s%s, flags '%s', reason: '%s'", user->nick.c_str(), freeform.c_str(), - type.c_str(), (duration ? ", duration " : ""), (duration ? parameters[3].c_str() : ""), - flags.c_str(), reason.c_str()); + user->WriteNotice("*** Added filter '" + freeform + "', type '" + parameters[1] + "'" + + (duration ? ", duration " + parameters[3] : "") + ", flags '" + flags + "', reason: '" + + parameters[reasonindex] + "'"); - ServerInstance->SNO->WriteToSnoMask(IS_LOCAL(user) ? 'a' : 'A', std::string("FILTER: ")+user->nick+" added filter '"+freeform+"', type '"+type+"', "+(duration ? "duration "+parameters[3]+", " : "")+"flags '"+flags+"', reason: "+reason); + ServerInstance->SNO->WriteToSnoMask(IS_LOCAL(user) ? 'a' : 'A', "FILTER: "+user->nick+" added filter '"+freeform+"', type '"+parameters[1]+"', "+(duration ? "duration "+parameters[3]+", " : "")+"flags '"+flags+"', reason: "+parameters[reasonindex]); return CMD_SUCCESS; } else { - user->WriteServ("NOTICE %s :*** Filter '%s' could not be added: %s", user->nick.c_str(), freeform.c_str(), result.second.c_str()); + user->WriteNotice("*** Filter '" + freeform + "' could not be added: " + result.second); return CMD_FAILURE; } } else { - this->TooFewParams(user, "."); + user->WriteNotice("*** Not enough parameters."); return CMD_FAILURE; } @@ -243,7 +278,7 @@ CmdResult CommandFilter::Handle(const std::vector ¶meters, User bool ModuleFilter::AppliesToMe(User* user, FilterResult* filter, int iflags) { - if ((filter->flag_no_opers) && IS_OPER(user)) + if ((filter->flag_no_opers) && user->IsOper()) return false; if ((iflags & FLAG_PRIVMSG) && (!filter->flag_privmsg)) return false; @@ -256,76 +291,74 @@ bool ModuleFilter::AppliesToMe(User* user, FilterResult* filter, int iflags) return true; } -ModuleFilter::ModuleFilter() : filtcommand(this), RegexEngine(this, "regex") +ModuleFilter::ModuleFilter() + : initing(true), filtcommand(this), RegexEngine(this, "regex") { } -void ModuleFilter::init() +CullResult ModuleFilter::cull() { - ServerInstance->AddCommand(&filtcommand); - Implementation eventlist[] = { I_OnPreCommand, I_OnStats, I_OnSyncNetwork, I_OnDecodeMetaData, I_OnUserPreMessage, I_OnUserPreNotice, I_OnRehash }; - ServerInstance->Modules->Attach(eventlist, this, 7); - OnRehash(NULL); + FreeFilters(); + return Module::cull(); } -ModuleFilter::~ModuleFilter() +void ModuleFilter::FreeFilters() { -} - -ModResult ModuleFilter::OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list) -{ - if (!IS_LOCAL(user)) - return MOD_RES_PASSTHRU; + for (std::vector::const_iterator i = filters.begin(); i != filters.end(); ++i) + delete i->regex; - flags = FLAG_PRIVMSG; - return OnUserPreNotice(user,dest,target_type,text,status,exempt_list); + filters.clear(); } -ModResult ModuleFilter::OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list) +ModResult ModuleFilter::OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) { - /* Leave ulines alone */ - if ((ServerInstance->ULine(user->server)) || (!IS_LOCAL(user))) + // Leave remote users and servers alone + if (!IS_LOCAL(user)) return MOD_RES_PASSTHRU; - if (!flags) - flags = FLAG_NOTICE; + flags = (msgtype == MSG_PRIVMSG) ? FLAG_PRIVMSG : FLAG_NOTICE; FilterResult* f = this->FilterMatch(user, text, flags); if (f) { - std::string target = ""; + std::string target; if (target_type == TYPE_USER) { User* t = (User*)dest; - target = std::string(t->nick); + // Check if the target nick is exempted, if yes, ignore this message + if (exemptednicks.count(t->nick)) + return MOD_RES_PASSTHRU; + + target = t->nick; } else if (target_type == TYPE_CHANNEL) { Channel* t = (Channel*)dest; - target = std::string(t->name); - std::vector::iterator i = find(exemptfromfilter.begin(), exemptfromfilter.end(), target); - if (i != exemptfromfilter.end()) return MOD_RES_PASSTHRU; + if (exemptedchans.count(t->name)) + return MOD_RES_PASSTHRU; + + target = t->name; } - if (f->action == "block") + if (f->action == FA_BLOCK) { - ServerInstance->SNO->WriteGlobalSno('a', std::string("FILTER: ")+user->nick+" had their message filtered, target was "+target+": "+f->reason); + ServerInstance->SNO->WriteGlobalSno('a', "FILTER: "+user->nick+" had their message filtered, target was "+target+": "+f->reason); if (target_type == TYPE_CHANNEL) - user->WriteNumeric(404, "%s %s :Message to channel blocked and opers notified (%s)",user->nick.c_str(), target.c_str(), f->reason.c_str()); + user->WriteNumeric(ERR_CANNOTSENDTOCHAN, target, InspIRCd::Format("Message to channel blocked and opers notified (%s)", f->reason.c_str())); else - user->WriteServ("NOTICE "+std::string(user->nick)+" :Your message to "+target+" was blocked and opers notified: "+f->reason); + user->WriteNotice("Your message to "+target+" was blocked and opers notified: "+f->reason); } - if (f->action == "silent") + else if (f->action == FA_SILENT) { if (target_type == TYPE_CHANNEL) - user->WriteNumeric(404, "%s %s :Message to channel blocked (%s)",user->nick.c_str(), target.c_str(), f->reason.c_str()); + user->WriteNumeric(ERR_CANNOTSENDTOCHAN, target, InspIRCd::Format("Message to channel blocked (%s)", f->reason.c_str())); else - user->WriteServ("NOTICE "+std::string(user->nick)+" :Your message to "+target+" was blocked: "+f->reason); + user->WriteNotice("Your message to "+target+" was blocked: "+f->reason); } - if (f->action == "kill") + else if (f->action == FA_KILL) { ServerInstance->Users->QuitUser(user, "Filtered: " + f->reason); } - if (f->action == "gline") + else if (f->action == FA_GLINE) { GLine* gl = new GLine(ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName.c_str(), f->reason.c_str(), "*", user->GetIPString()); if (ServerInstance->XLines->AddLine(gl,NULL)) @@ -336,7 +369,7 @@ ModResult ModuleFilter::OnUserPreNotice(User* user,void* dest,int target_type, s delete gl; } - ServerInstance->Logs->Log("FILTER",DEFAULT,"FILTER: "+ user->nick + " had their message filtered, target was " + target + ": " + f->reason + " Action: " + f->action); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, user->nick + " had their message filtered, target was " + target + ": " + f->reason + " Action: " + ModuleFilter::FilterActionToString(f->action)); return MOD_RES_DENY; } return MOD_RES_PASSTHRU; @@ -344,12 +377,10 @@ ModResult ModuleFilter::OnUserPreNotice(User* user,void* dest,int target_type, s ModResult ModuleFilter::OnPreCommand(std::string &command, std::vector ¶meters, LocalUser *user, bool validated, const std::string &original_line) { - flags = 0; - if (validated && IS_LOCAL(user)) + if (validated) { - std::string checkline; - int replacepoint = 0; - bool parting = false; + flags = 0; + bool parting; if (command == "QUIT") { @@ -357,8 +388,6 @@ ModResult ModuleFilter::OnPreCommand(std::string &command, std::vector::iterator i = find(exemptfromfilter.begin(), exemptfromfilter.end(), parameters[0]); - if (i != exemptfromfilter.end()) return MOD_RES_PASSTHRU; - checkline = parameters[1]; - replacepoint = 1; + if (exemptedchans.count(parameters[0])) + return MOD_RES_PASSTHRU; + parting = true; flags = FLAG_PART; } @@ -379,85 +407,96 @@ ModResult ModuleFilter::OnPreCommand(std::string &command, std::vectorFilterMatch(user, checkline, flags); - + FilterResult* f = this->FilterMatch(user, parameters[parting ? 1 : 0], flags); if (!f) /* PART or QUIT reason doesnt match a filter */ return MOD_RES_PASSTHRU; /* We cant block a part or quit, so instead we change the reason to 'Reason filtered' */ - Command* c = ServerInstance->Parser->GetHandler(command); - if (c) + parameters[parting ? 1 : 0] = "Reason filtered"; + + /* We're blocking, OR theyre quitting and its a KILL action + * (we cant kill someone whos already quitting, so filter them anyway) + */ + if ((f->action == FA_BLOCK) || (((!parting) && (f->action == FA_KILL))) || (f->action == FA_SILENT)) + { + return MOD_RES_PASSTHRU; + } + else { - std::vector params; - for (int item = 0; item < (int)parameters.size(); item++) - params.push_back(parameters[item]); - params[replacepoint] = "Reason filtered"; - - /* We're blocking, OR theyre quitting and its a KILL action - * (we cant kill someone whos already quitting, so filter them anyway) - */ - if ((f->action == "block") || (((!parting) && (f->action == "kill"))) || (f->action == "silent")) + /* Are they parting, if so, kill is applicable */ + if ((parting) && (f->action == FA_KILL)) { - c->Handle(params, user); - return MOD_RES_DENY; + user->WriteNotice("*** Your PART message was filtered: " + f->reason); + ServerInstance->Users->QuitUser(user, "Filtered: " + f->reason); } - else + if (f->action == FA_GLINE) { - /* Are they parting, if so, kill is applicable */ - if ((parting) && (f->action == "kill")) - { - user->WriteServ("NOTICE %s :*** Your PART message was filtered: %s", user->nick.c_str(), f->reason.c_str()); - ServerInstance->Users->QuitUser(user, "Filtered: " + f->reason); - } - if (f->action == "gline") + /* Note: We gline *@IP so that if their host doesnt resolve the gline still applies. */ + GLine* gl = new GLine(ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName.c_str(), f->reason.c_str(), "*", user->GetIPString()); + if (ServerInstance->XLines->AddLine(gl,NULL)) { - /* Note: We gline *@IP so that if their host doesnt resolve the gline still applies. */ - GLine* gl = new GLine(ServerInstance->Time(), f->gline_time, ServerInstance->Config->ServerName.c_str(), f->reason.c_str(), "*", user->GetIPString()); - if (ServerInstance->XLines->AddLine(gl,NULL)) - { - ServerInstance->XLines->ApplyLines(); - } - else - delete gl; + ServerInstance->XLines->ApplyLines(); } - return MOD_RES_DENY; + else + delete gl; } + return MOD_RES_DENY; } - return MOD_RES_PASSTHRU; } return MOD_RES_PASSTHRU; } -void ModuleFilter::OnRehash(User* user) +void ModuleFilter::ReadConfig(ConfigStatus& status) { - ConfigReader MyConf; - std::vector().swap(exemptfromfilter); - for (int index = 0; index < MyConf.Enumerate("exemptfromfilter"); ++index) + ConfigTagList tags = ServerInstance->Config->ConfTags("exemptfromfilter"); + exemptedchans.clear(); + exemptednicks.clear(); + + for (ConfigIter i = tags.first; i != tags.second; ++i) { - std::string chan = MyConf.ReadValue("exemptfromfilter", "channel", index); - if (!chan.empty()) { - exemptfromfilter.push_back(chan); + ConfigTag* tag = i->second; + + // If "target" is not found, try the old "channel" key to keep compatibility with 2.0 configs + const std::string target = tag->getString("target", tag->getString("channel")); + if (!target.empty()) + { + if (target[0] == '#') + exemptedchans.insert(target); + else + exemptednicks.insert(target); } } - std::string newrxengine = "regex/" + MyConf.ReadValue("filteropts", "engine", 0); - if (newrxengine == "regex/") - newrxengine = "regex"; - if (RegexEngine.GetProvider() == newrxengine) - return; - //ServerInstance->SNO->WriteGlobalSno('a', "Dumping all filters due to regex engine change (was '%s', now '%s')", RegexEngine.GetProvider().c_str(), newrxengine.c_str()); - //ServerInstance->XLines->DelAll("R"); + std::string newrxengine = ServerInstance->Config->ConfValue("filteropts")->getString("engine"); + + factory = RegexEngine ? (RegexEngine.operator->()) : NULL; + + if (newrxengine.empty()) + RegexEngine.SetProvider("regex"); + else + RegexEngine.SetProvider("regex/" + newrxengine); - RegexEngine.SetProvider(newrxengine); if (!RegexEngine) { - ServerInstance->SNO->WriteGlobalSno('a', "WARNING: Regex engine '%s' is not loaded - Filter functionality disabled until this is corrected.", newrxengine.c_str()); + if (newrxengine.empty()) + ServerInstance->SNO->WriteGlobalSno('a', "WARNING: No regex engine loaded - Filter functionality disabled until this is corrected."); + else + ServerInstance->SNO->WriteGlobalSno('a', "WARNING: Regex engine '%s' is not loaded - Filter functionality disabled until this is corrected.", newrxengine.c_str()); + + initing = false; + FreeFilters(); + return; } - ReadFilters(MyConf); + + if ((!initing) && (RegexEngine.operator->() != factory)) + { + ServerInstance->SNO->WriteGlobalSno('a', "Dumping all filters due to regex engine change"); + FreeFilters(); + } + + initing = false; + ReadFilters(); } Version ModuleFilter::GetVersion() @@ -465,7 +504,6 @@ Version ModuleFilter::GetVersion() return Version("Text (spam) filtering", VF_VENDOR | VF_COMMON, RegexEngine ? RegexEngine->name : ""); } - std::string ModuleFilter::EncodeFilter(FilterResult* filter) { std::ostringstream stream; @@ -476,20 +514,26 @@ std::string ModuleFilter::EncodeFilter(FilterResult* filter) if (*n == ' ') *n = '\7'; - stream << x << " " << filter->action << " " << (filter->flags.empty() ? "-" : filter->flags) << " " << filter->gline_time << " :" << filter->reason; + stream << x << " " << FilterActionToString(filter->action) << " " << filter->GetFlags() << " " << filter->gline_time << " :" << filter->reason; return stream.str(); } FilterResult ModuleFilter::DecodeFilter(const std::string &data) { + std::string filteraction; FilterResult res; 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); + tokens.GetToken(filteraction); + if (!StringToFilterAction(filteraction, res.action)) + throw ModuleException("Invalid action: " + filteraction); + + std::string filterflags; + tokens.GetToken(filterflags); + char c = res.FillFlags(filterflags); + if (c != 0) + throw ModuleException("Invalid flag: '" + std::string(1, c) + "'"); + tokens.GetToken(res.gline_time); tokens.GetToken(res.reason); @@ -501,62 +545,58 @@ FilterResult ModuleFilter::DecodeFilter(const std::string &data) return res; } -void ModuleFilter::OnSyncNetwork(Module* proto, void* opaque) +void ModuleFilter::OnSyncNetwork(ProtocolInterface::Server& server) { - this->SyncFilters(proto, opaque); -} - -void ModuleFilter::SendFilter(Module* proto, void* opaque, FilterResult* iter) -{ - proto->ProtoSendMetaData(opaque, NULL, "filter", EncodeFilter(iter)); + for (std::vector::iterator i = filters.begin(); i != filters.end(); ++i) + { + server.SendMetaData("filter", EncodeFilter(&(*i))); + } } void ModuleFilter::OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata) { if ((target == NULL) && (extname == "filter")) { - FilterResult data = DecodeFilter(extdata); - this->AddFilter(data.freeform, data.action, data.reason, data.gline_time, data.flags); + try + { + FilterResult data = DecodeFilter(extdata); + this->AddFilter(data.freeform, data.action, data.reason, data.gline_time, data.GetFlags()); + } + catch (ModuleException& e) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Error when unserializing filter: " + e.GetReason()); + } } } -ImplFilter::ImplFilter(ModuleFilter* mymodule, const std::string &rea, const std::string &act, long glinetime, const std::string &pat, const std::string &flgs) - : FilterResult(pat, rea, act, glinetime, flgs) -{ - if (!mymodule->RegexEngine) - throw ModuleException("Regex module implementing '"+mymodule->RegexEngine.GetProvider()+"' is not loaded!"); - regex = mymodule->RegexEngine->Create(pat); -} - FilterResult* ModuleFilter::FilterMatch(User* user, const std::string &text, int flgs) { - for (std::vector::iterator index = filters.begin(); index != filters.end(); index++) + static std::string stripped_text; + stripped_text.clear(); + + for (std::vector::iterator i = filters.begin(); i != filters.end(); ++i) { + FilterResult* filter = &*i; + /* Skip ones that dont apply to us */ - if (!AppliesToMe(user, dynamic_cast(&(*index)), flgs)) + if (!AppliesToMe(user, filter, flgs)) continue; - //ServerInstance->Logs->Log("m_filter", DEBUG, "Match '%s' against '%s'", text.c_str(), index->freeform.c_str()); - if (index->regex->Matches(text)) + if ((filter->flag_strip_color) && (stripped_text.empty())) { - //ServerInstance->Logs->Log("m_filter", DEBUG, "MATCH"); - ImplFilter fr = *index; - if (index != filters.begin()) - { - /* Move to head of list for efficiency */ - filters.erase(index); - filters.insert(filters.begin(), fr); - } - return &*filters.begin(); + stripped_text = text; + InspIRCd::StripColor(stripped_text); } - //ServerInstance->Logs->Log("m_filter", DEBUG, "NO MATCH"); + + if (filter->regex->Matches(filter->flag_strip_color ? stripped_text : text)) + return filter; } return NULL; } bool ModuleFilter::DeleteFilter(const std::string &freeform) { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) { if (i->freeform == freeform) { @@ -568,17 +608,9 @@ bool ModuleFilter::DeleteFilter(const std::string &freeform) return false; } -void ModuleFilter::SyncFilters(Module* proto, void* opaque) -{ - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) - { - this->SendFilter(proto, opaque, &(*i)); - } -} - -std::pair ModuleFilter::AddFilter(const std::string &freeform, const std::string &type, const std::string &reason, long duration, const std::string &flgs) +std::pair ModuleFilter::AddFilter(const std::string &freeform, FilterAction type, const std::string &reason, long duration, const std::string &flgs) { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) { if (i->freeform == freeform) { @@ -588,59 +620,111 @@ std::pair ModuleFilter::AddFilter(const std::string &freeform try { - filters.push_back(ImplFilter(this, reason, type, duration, freeform, flgs)); + filters.push_back(FilterResult(RegexEngine, freeform, reason, type, duration, flgs)); } catch (ModuleException &e) { - ServerInstance->Logs->Log("m_filter", DEFAULT, "Error in regular expression '%s': %s", freeform.c_str(), e.GetReason()); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Error in regular expression '%s': %s", freeform.c_str(), e.GetReason().c_str()); return std::make_pair(false, e.GetReason()); } return std::make_pair(true, ""); } -void ModuleFilter::ReadFilters(ConfigReader &MyConf) +bool ModuleFilter::StringToFilterAction(const std::string& str, FilterAction& fa) +{ + irc::string s(str.c_str()); + + if (s == "gline") + fa = FA_GLINE; + else if (s == "block") + fa = FA_BLOCK; + else if (s == "silent") + fa = FA_SILENT; + else if (s == "kill") + fa = FA_KILL; + else if (s == "none") + fa = FA_NONE; + else + return false; + + return true; +} + +std::string ModuleFilter::FilterActionToString(FilterAction fa) +{ + switch (fa) + { + case FA_GLINE: return "gline"; + case FA_BLOCK: return "block"; + case FA_SILENT: return "silent"; + case FA_KILL: return "kill"; + default: return "none"; + } +} + +void ModuleFilter::ReadFilters() { - for (int index = 0; index < MyConf.Enumerate("keyword"); index++) + ConfigTagList tags = ServerInstance->Config->ConfTags("keyword"); + for (ConfigIter i = tags.first; i != tags.second; ++i) { - this->DeleteFilter(MyConf.ReadValue("keyword", "pattern", index)); - - std::string pattern = MyConf.ReadValue("keyword", "pattern", index); - std::string reason = MyConf.ReadValue("keyword", "reason", index); - std::string action = MyConf.ReadValue("keyword", "action", index); - std::string flgs = MyConf.ReadValue("keyword", "flags", index); - long gline_time = ServerInstance->Duration(MyConf.ReadValue("keyword", "duration", index)); - if (action.empty()) - action = "none"; + std::string pattern = i->second->getString("pattern"); + this->DeleteFilter(pattern); + + std::string reason = i->second->getString("reason"); + std::string action = i->second->getString("action"); + std::string flgs = i->second->getString("flags"); + unsigned long gline_time = i->second->getDuration("duration", 10*60, 1); if (flgs.empty()) flgs = "*"; + FilterAction fa; + if (!StringToFilterAction(action, fa)) + fa = FA_NONE; + try { - filters.push_back(ImplFilter(this, reason, action, gline_time, pattern, flgs)); - ServerInstance->Logs->Log("m_filter", DEFAULT, "Regular expression %s loaded.", pattern.c_str()); + filters.push_back(FilterResult(RegexEngine, pattern, reason, fa, gline_time, flgs)); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Regular expression %s loaded.", pattern.c_str()); } catch (ModuleException &e) { - ServerInstance->Logs->Log("m_filter", DEFAULT, "Error in regular expression '%s': %s", pattern.c_str(), e.GetReason()); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Error in regular expression '%s': %s", pattern.c_str(), e.GetReason().c_str()); } } } -ModResult ModuleFilter::OnStats(char symbol, User* user, string_list &results) +ModResult ModuleFilter::OnStats(Stats::Context& stats) { - if (symbol == 's') + if (stats.GetSymbol() == 's') { - std::string sn = ServerInstance->Config->ServerName; - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) { - results.push_back(sn+" 223 "+user->nick+" :"+RegexEngine.GetProvider()+":"+i->freeform+" "+i->flags+" "+i->action+" "+ConvToStr(i->gline_time)+" :"+i->reason); + stats.AddRow(223, RegexEngine.GetProvider()+":"+i->freeform+" "+i->GetFlags()+" "+FilterActionToString(i->action)+" "+ConvToStr(i->gline_time)+" :"+i->reason); } - for (std::vector::iterator i = exemptfromfilter.begin(); i != exemptfromfilter.end(); ++i) + for (ExemptTargetSet::const_iterator i = exemptedchans.begin(); i != exemptedchans.end(); ++i) { - results.push_back(sn+" 223 "+user->nick+" :EXEMPT "+(*i)); + stats.AddRow(223, "EXEMPT "+(*i)); + } + for (ExemptTargetSet::const_iterator i = exemptednicks.begin(); i != exemptednicks.end(); ++i) + { + stats.AddRow(223, "EXEMPT "+(*i)); } } return MOD_RES_PASSTHRU; } +void ModuleFilter::OnUnloadModule(Module* mod) +{ + // If the regex engine became unavailable or has changed, remove all filters + if (!RegexEngine) + { + FreeFilters(); + } + else if (RegexEngine.operator->() != factory) + { + factory = RegexEngine.operator->(); + FreeFilters(); + } +} + MODULE_INIT(ModuleFilter)