X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_rline.cpp;h=9d090ec2ed45e1f08dd59e64bd464d5801930346;hb=0da6b3a13def40e8fd002b9fc60f955467f6372d;hp=6cae0badf40198d8730bfb6dd096e99a318fcd12;hpb=f60dc75f47df8c534d1ce303062b0ef3f2aa1e14;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_rline.cpp b/src/modules/m_rline.cpp index 6cae0badf..9d090ec2e 100644 --- a/src/modules/m_rline.cpp +++ b/src/modules/m_rline.cpp @@ -2,182 +2,314 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * InspIRCd: (C) 2002-2009 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits * * This program is free but copyrighted software; see - * the file COPYING for details. + * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" -#include -#include "users.h" -#include "channels.h" -#include "modules.h" -#include "m_filter.h" - -/* $ModDesc: m_filter with regexps */ -/* $CompileFlags: exec("pcre-config --cflags") */ -/* $LinkerFlags: exec("pcre-config --libs") rpath("pcre-config --libs") -lpcre */ -/* $ModDep: m_filter.h */ - -#ifdef WINDOWS -#pragma comment(lib, "pcre.lib") -#endif - -class PCREFilter : public FilterResult +#include "m_regex.h" +#include "xline.h" + +static Module* rxengine = NULL; +static Module* mymodule = NULL; /* Needed to let RLine send request! */ + +/* $ModDesc: RLINE: Regexp user banning. */ + +class RLine : public XLine { public: - pcre* regexp; - PCREFilter(pcre* r, const std::string &rea, const std::string &act, long gline_time, const std::string &pat, const std::string &flags) - : FilterResult(pat, rea, act, gline_time, flags), regexp(r) - { - } + /** Create a R-Line. + * @param s_time The set time + * @param d The duration of the xline + * @param src The sender of the xline + * @param re The reason of the xline + * @param regex Pattern to match with + * @ + */ + RLine(InspIRCd* Instance, time_t s_time, long d, const char* src, const char* re, const char* regexs) : XLine(Instance, s_time, d, src, re, "R") + { + matchtext = regexs; + + if (!rxengine) + { + ServerInstance->SNO->WriteToSnoMask('x', "Cannot create regexes until engine is set to a loaded provider!"); + throw ModuleException("Regex engine not set or loaded!"); + } + + /* This can throw on failure, but if it does we DONT catch it here, we catch it and display it + * where the object is created, we might not ALWAYS want it to output stuff to snomask x all the time + */ + regex = RegexFactoryRequest(mymodule, rxengine, regexs).Create(); + } + + /** Destructor + */ + ~RLine() + { + delete regex; + } + + bool Matches(User *u) + { + if (u->exempt) + return false; + + std::string compare = u->nick + "!" + u->ident + "@" + u->host + " " + u->fullname; + return regex->Matches(compare); + } + + bool Matches(const std::string &compare) + { + return regex->Matches(compare); + } + + void Apply(User* u) + { + DefaultApply(u, "R", true); + } + + void DisplayExpiry() + { + ServerInstance->SNO->WriteToSnoMask('x',"Removing expired R-Line %s (set by %s %ld seconds ago)", this->matchtext.c_str(), this->source, (long int)(ServerInstance->Time() - this->set_time)); + } + + const char* Displayable() + { + return matchtext.c_str(); + } + + std::string matchtext; - PCREFilter() - { - } + Regex *regex; }; -class ModuleFilterPCRE : public FilterBase -{ - std::vector filters; - pcre *re; - const char *error; - int erroffset; - PCREFilter fr; +/** An XLineFactory specialized to generate RLine* pointers + */ +class RLineFactory : public XLineFactory +{ public: - ModuleFilterPCRE(InspIRCd* Me) - : FilterBase(Me, "m_filter_pcre.so") + RLineFactory(InspIRCd* Instance) : XLineFactory(Instance, "R") { - OnRehash(NULL,""); + } + /** Generate a RLine + */ + XLine* Generate(time_t set_time, long duration, const char* source, const char* reason, const char* xline_specific_mask) + { + return new RLine(ServerInstance, set_time, duration, source, reason, xline_specific_mask); } - virtual ~ModuleFilterPCRE() + ~RLineFactory() { } +}; + +/** Handle /RLINE + * Syntax is same as other lines: RLINE regex_goes_here 1d :reason + */ +class CommandRLine : public Command +{ + std::string rxengine; - virtual FilterResult* FilterMatch(User* user, const std::string &text, int flags) + public: + CommandRLine (InspIRCd* Instance) : Command(Instance,"RLINE", "o", 1, 3) { - for (std::vector::iterator index = filters.begin(); index != filters.end(); index++) + this->source = "m_rline.so"; + this->syntax = " [] :"; + } + + CmdResult Handle (const std::vector& parameters, User *user) + { + + if (parameters.size() >= 3) { - /* Skip ones that dont apply to us */ + // Adding - XXX todo make this respect tag perhaps.. - if (!FilterBase::AppliesToMe(user, dynamic_cast(&(*index)), flags)) - continue; + long duration = ServerInstance->Duration(parameters[1]); + RLine *r = NULL; + + try + { + r = new RLine(ServerInstance, ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str()); + } + catch (ModuleException &e) + { + ServerInstance->SNO->WriteToSnoMask('x',"Could not add RLINE: %s", e.GetReason()); + } - if (pcre_exec(index->regexp, NULL, text.c_str(), text.length(), 0, 0, NULL, 0) > -1) + if (r) { - fr = *index; - if (index != filters.begin()) + if (ServerInstance->XLines->AddLine(r, user)) { - filters.erase(index); - filters.insert(filters.begin(), fr); + if (!duration) + { + ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent R-Line for %s: %s", user->nick.c_str(), parameters[0].c_str(), parameters[2].c_str()); + } + else + { + time_t c_requires_crap = duration + ServerInstance->Time(); + ServerInstance->SNO->WriteToSnoMask('x', "%s added timed R-Line for %s, expires on %s: %s", user->nick.c_str(), parameters[0].c_str(), ServerInstance->TimeString(c_requires_crap).c_str(), parameters[2].c_str()); + } + + ServerInstance->XLines->ApplyLines(); + } + else + { + delete r; + user->WriteServ("NOTICE %s :*** R-Line for %s already exists", user->nick.c_str(), parameters[0].c_str()); } - return &fr; } } - return NULL; - } - - virtual bool DeleteFilter(const std::string &freeform) - { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + else { - if (i->freeform == freeform) + if (ServerInstance->XLines->DelLine(parameters[0].c_str(), "R", user)) + { + ServerInstance->SNO->WriteToSnoMask('x',"%s Removed R-Line on %s.",user->nick.c_str(),parameters[0].c_str()); + } + else { - pcre_free((*i).regexp); - filters.erase(i); - return true; + user->WriteServ("NOTICE %s :*** R-Line %s not found in list, try /stats R.",user->nick.c_str(),parameters[0].c_str()); } } - return false; + + return CMD_SUCCESS; } +}; + +class ModuleRLine : public Module +{ + private: + CommandRLine *r; + RLineFactory *f; + bool MatchOnNickChange; + std::string RegexEngine; - virtual void SyncFilters(Module* proto, void* opaque) + public: + ModuleRLine(InspIRCd* Me) : Module(Me) { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) - { - this->SendFilter(proto, opaque, &(*i)); - } + mymodule = this; + OnRehash(NULL); + + Me->Modules->UseInterface("RegularExpression"); + + // Create a new command + r = new CommandRLine(ServerInstance); + ServerInstance->AddCommand(r); + + f = new RLineFactory(ServerInstance); + ServerInstance->XLines->RegisterFactory(f); + + Implementation eventlist[] = { I_OnUserConnect, I_OnRehash, I_OnUserPostNick, I_OnLoadModule, I_OnStats }; + ServerInstance->Modules->Attach(eventlist, this, 5); + } - virtual std::pair AddFilter(const std::string &freeform, const std::string &type, const std::string &reason, long duration, const std::string &flags) + virtual ~ModuleRLine() { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) - { - if (i->freeform == freeform) - { - return std::make_pair(false, "Filter already exists"); - } - } + ServerInstance->Modules->DoneWithInterface("RegularExpression"); + ServerInstance->XLines->DelAll("R"); + ServerInstance->XLines->UnregisterFactory(f); + } - re = pcre_compile(freeform.c_str(),0,&error,&erroffset,NULL); + virtual Version GetVersion() + { + return Version("$Id$", VF_COMMON | VF_VENDOR, API_VERSION); + } - if (!re) - { - ServerInstance->Log(DEFAULT,"Error in regular expression: %s at offset %d: %s\n", freeform.c_str(), erroffset, error); - ServerInstance->Log(DEFAULT,"Regular expression %s not loaded.", freeform.c_str()); - return std::make_pair(false, "Error in regular expression at offset " + ConvToStr(erroffset) + ": "+error); - } - else + virtual void OnUserConnect(User* user) + { + // Apply lines on user connect + XLine *rl = ServerInstance->XLines->MatchesLine("R", user); + + if (rl) { - filters.push_back(PCREFilter(re, reason, type, duration, freeform, flags)); - return std::make_pair(true, ""); + // Bang. :P + rl->Apply(user); } } - virtual void OnRehash(User* user, const std::string ¶meter) - { - ConfigReader MyConf(ServerInstance); - - for (int index = 0; index < MyConf.Enumerate("keyword"); index++) - { - this->DeleteFilter(MyConf.ReadValue("keyword", "pattern", index)); + virtual void OnRehash(User *user) + { + ConfigReader Conf(ServerInstance); - 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 flags = MyConf.ReadValue("keyword", "flags", index); - long gline_time = ServerInstance->Duration(MyConf.ReadValue("keyword", "duration", index)); - if (action.empty()) - action = "none"; - if (flags.empty()) - flags = "*"; + MatchOnNickChange = Conf.ReadFlag("rline", "matchonnickchange", 0); + std::string newrxengine = Conf.ReadValue("rline", "engine", 0); - re = pcre_compile(pattern.c_str(),0,&error,&erroffset,NULL); + if (!RegexEngine.empty()) + { + if (RegexEngine == newrxengine) + return; - if (!re) - { - ServerInstance->Log(DEFAULT,"Error in regular expression: %s at offset %d: %s\n", pattern.c_str(), erroffset, error); - ServerInstance->Log(DEFAULT,"Regular expression %s not loaded.", pattern.c_str()); - } - else + ServerInstance->SNO->WriteToSnoMask('x', "Dumping all R-Lines due to regex engine change (was '%s', now '%s')", RegexEngine.c_str(), newrxengine.c_str()); + ServerInstance->XLines->DelAll("R"); + } + rxengine = 0; + RegexEngine = newrxengine; + modulelist* ml = ServerInstance->Modules->FindInterface("RegularExpression"); + if (ml) + { + for (modulelist::iterator i = ml->begin(); i != ml->end(); ++i) { - filters.push_back(PCREFilter(re, reason, action, gline_time, pattern, flags)); - ServerInstance->Log(DEFAULT,"Regular expression %s loaded.", pattern.c_str()); + if (RegexNameRequest(this, *i).Send() == newrxengine) + { + ServerInstance->SNO->WriteToSnoMask('x', "R-Line now using engine '%s'", RegexEngine.c_str()); + rxengine = *i; + } } } + if (!rxengine) + { + ServerInstance->SNO->WriteToSnoMask('x', "WARNING: Regex engine '%s' is not loaded - R-Line functionality disabled until this is corrected.", RegexEngine.c_str()); + } } virtual int OnStats(char symbol, User* user, string_list &results) { - if (symbol == 's') + if (symbol != 'R') + return 0; + + ServerInstance->XLines->InvokeStats("R", 223, user, results); + return 1; + } + + virtual void OnLoadModule(Module* mod, const std::string& name) + { + if (ServerInstance->Modules->ModuleHasInterface(mod, "RegularExpression")) { - std::string sn = ServerInstance->Config->ServerName; - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + std::string rxname = RegexNameRequest(this, mod).Send(); + if (rxname == RegexEngine) { - results.push_back(sn+" 223 "+user->nick+" :REGEXP:"+i->freeform+" "+i->flags+" "+i->action+" "+ConvToStr(i->gline_time)+" :"+i->reason); + ServerInstance->SNO->WriteToSnoMask('x', "R-Line now using engine '%s'", RegexEngine.c_str()); + rxengine = mod; } } - return 0; } + + virtual void OnUserPostNick(User *user, const std::string &oldnick) + { + if (!IS_LOCAL(user)) + return; + + if (!MatchOnNickChange) + return; + + XLine *rl = ServerInstance->XLines->MatchesLine("R", user); + + if (rl) + { + // Bang! :D + rl->Apply(user); + } + } + }; -MODULE_INIT(ModuleFilterPCRE) +MODULE_INIT(ModuleRLine)