X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_rline.cpp;h=e6414c5dd85f53b847e4387e6f1abdf8bd9af6ca;hb=fd8faa7e21994dee0a6d3d09abebb3004311408e;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..e6414c5dd 100644 --- a/src/modules/m_rline.cpp +++ b/src/modules/m_rline.cpp @@ -1,183 +1,361 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2007 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2018 linuxdaemon + * Copyright (C) 2017, 2019 Matt Schatz + * Copyright (C) 2013, 2017-2018, 2020 Sadie Powell + * Copyright (C) 2012-2013, 2016 Attila Molnar + * Copyright (C) 2012, 2018-2019 Robby + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2009 Uli Schlachter + * Copyright (C) 2008-2009 Robin Burchell + * Copyright (C) 2008 Thomas Stagner + * Copyright (C) 2008 Craig Edwards * - * 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 -#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 "modules/regex.h" +#include "modules/stats.h" +#include "xline.h" + +static bool ZlineOnMatch = false; +static bool added_zline = false; + +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(time_t s_time, unsigned long d, const std::string& src, const std::string& re, const std::string& regexs, dynamic_reference& rxfactory) + : XLine(s_time, d, src, re, "R") + , matchtext(regexs) + { + /* 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 = rxfactory->Create(regexs); + } + + /** Destructor + */ + ~RLine() + { + delete regex; + } + + bool Matches(User* u) CXX11_OVERRIDE + { + LocalUser* lu = IS_LOCAL(u); + if (lu && lu->exempt) + return false; + + const std::string host = u->nick + "!" + u->ident + "@" + u->GetRealHost() + " " + u->GetRealName(); + const std::string ip = u->nick + "!" + u->ident + "@" + u->GetIPString() + " " + u->GetRealName(); + return (regex->Matches(host) || regex->Matches(ip)); + } + + bool Matches(const std::string& compare) CXX11_OVERRIDE + { + return regex->Matches(compare); + } + + void Apply(User* u) CXX11_OVERRIDE + { + if (ZlineOnMatch) + { + ZLine* zl = new ZLine(ServerInstance->Time(), duration ? expiry - ServerInstance->Time() : 0, ServerInstance->Config->ServerName.c_str(), reason.c_str(), u->GetIPString()); + if (ServerInstance->XLines->AddLine(zl, NULL)) + { + std::string expirystr = zl->duration ? InspIRCd::Format(" to expire in %s (on %s)", InspIRCd::DurationString(zl->duration).c_str(), InspIRCd::TimeString(zl->expiry).c_str()) : ""; + ServerInstance->SNO->WriteToSnoMask('x', "Z-line added due to R-line match on %s%s: %s", + zl->ipaddr.c_str(), expirystr.c_str(), zl->reason.c_str()); + added_zline = true; + } + else + delete zl; + } + DefaultApply(u, "R", false); + } + + const std::string& Displayable() CXX11_OVERRIDE + { + return matchtext; + } - PCREFilter() - { - } + std::string matchtext; + + 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") + dynamic_reference& rxfactory; + RLineFactory(dynamic_reference& rx) : XLineFactory("R"), rxfactory(rx) + { + } + + /** Generate a RLine + */ + XLine* Generate(time_t set_time, unsigned long duration, const std::string& source, const std::string& reason, const std::string& xline_specific_mask) CXX11_OVERRIDE { - OnRehash(NULL,""); + if (!rxfactory) + { + ServerInstance->SNO->WriteToSnoMask('a', "Cannot create regexes until engine is set to a loaded provider!"); + throw ModuleException("Regex engine not set or loaded!"); + } + return new RLine(set_time, duration, source, reason, xline_specific_mask, rxfactory); } +}; - virtual ~ModuleFilterPCRE() +/** Handle /RLINE + * Syntax is same as other lines: RLINE regex_goes_here 1d :reason + */ +class CommandRLine : public Command +{ + std::string rxengine; + RLineFactory& factory; + + public: + CommandRLine(Module* Creator, RLineFactory& rlf) : Command(Creator,"RLINE", 1, 3), factory(rlf) { + flags_needed = 'o'; this->syntax = " [ :]"; } - virtual FilterResult* FilterMatch(User* user, const std::string &text, int flags) + CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE { - for (std::vector::iterator index = filters.begin(); index != filters.end(); index++) + + 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; + unsigned long duration; + if (!InspIRCd::Duration(parameters[1], duration)) + { + user->WriteNotice("*** Invalid duration for R-line."); + return CMD_FAILURE; + } + XLine *r = NULL; - if (pcre_exec(index->regexp, NULL, text.c_str(), text.length(), 0, 0, NULL, 0) > -1) + try { - fr = *index; - if (index != filters.begin()) + r = factory.Generate(ServerInstance->Time(), duration, user->nick.c_str(), parameters[2].c_str(), parameters[0].c_str()); + } + catch (ModuleException &e) + { + ServerInstance->SNO->WriteToSnoMask('a', "Could not add R-line: " + e.GetReason()); + } + + if (r) + { + if (ServerInstance->XLines->AddLine(r, user)) + { + 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 + { + ServerInstance->SNO->WriteToSnoMask('x', "%s added timed R-line for %s, expires in %s (on %s): %s", + user->nick.c_str(), parameters[0].c_str(), InspIRCd::DurationString(duration).c_str(), + InspIRCd::TimeString(ServerInstance->Time() + duration).c_str(), parameters[2].c_str()); + } + + ServerInstance->XLines->ApplyLines(); + } + else { - filters.erase(index); - filters.insert(filters.begin(), fr); + delete r; + user->WriteNotice("*** R-line for " + parameters[0] + " already exists."); } - 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) + std::string reason; + + if (ServerInstance->XLines->DelLine(parameters[0].c_str(), "R", reason, user)) { - pcre_free((*i).regexp); - filters.erase(i); - return true; + ServerInstance->SNO->WriteToSnoMask('x', "%s removed R-line on %s: %s", user->nick.c_str(), parameters[0].c_str(), reason.c_str()); + } + else + { + user->WriteNotice("*** R-line " + parameters[0] + " not found on the list."); } } - return false; + + return CMD_SUCCESS; } - virtual void SyncFilters(Module* proto, void* opaque) + RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) - { - this->SendFilter(proto, opaque, &(*i)); - } + if (IS_LOCAL(user)) + return ROUTE_LOCALONLY; // spanningtree will send ADDLINE + + return ROUTE_BROADCAST; + } +}; + +class ModuleRLine : public Module, public Stats::EventListener +{ + dynamic_reference rxfactory; + RLineFactory f; + CommandRLine r; + bool MatchOnNickChange; + bool initing; + RegexFactory* factory; + + public: + ModuleRLine() + : Stats::EventListener(this) + , rxfactory(this, "regex") + , f(rxfactory) + , r(this, f) + , initing(true) + { + } + + void init() CXX11_OVERRIDE + { + ServerInstance->XLines->RegisterFactory(&f); } - virtual std::pair AddFilter(const std::string &freeform, const std::string &type, const std::string &reason, long duration, const std::string &flags) + ~ModuleRLine() { - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) + ServerInstance->XLines->DelAll("R"); + ServerInstance->XLines->UnregisterFactory(&f); + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Adds the /RLINE command which allows server operators to prevent users matching a nickname!username@hostname+realname regular expression from connecting to the server.", VF_COMMON | VF_VENDOR, rxfactory ? rxfactory->name : ""); + } + + ModResult OnUserRegister(LocalUser* user) CXX11_OVERRIDE + { + // Apply lines on user connect + XLine *rl = ServerInstance->XLines->MatchesLine("R", user); + + if (rl) { - if (i->freeform == freeform) - { - return std::make_pair(false, "Filter already exists"); - } + // Bang. :P + rl->Apply(user); + return MOD_RES_DENY; } + return MOD_RES_PASSTHRU; + } + + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE + { + ConfigTag* tag = ServerInstance->Config->ConfValue("rline"); + + MatchOnNickChange = tag->getBool("matchonnickchange"); + ZlineOnMatch = tag->getBool("zlineonmatch"); + std::string newrxengine = tag->getString("engine"); + + factory = rxfactory ? (rxfactory.operator->()) : NULL; - re = pcre_compile(freeform.c_str(),0,&error,&erroffset,NULL); + if (newrxengine.empty()) + rxfactory.SetProvider("regex"); + else + rxfactory.SetProvider("regex/" + newrxengine); - if (!re) + if (!rxfactory) { - 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); + if (newrxengine.empty()) + ServerInstance->SNO->WriteToSnoMask('a', "WARNING: No regex engine loaded - R-line functionality disabled until this is corrected."); + else + ServerInstance->SNO->WriteToSnoMask('a', "WARNING: Regex engine '%s' is not loaded - R-line functionality disabled until this is corrected.", newrxengine.c_str()); + + ServerInstance->XLines->DelAll(f.GetType()); } - else + else if ((!initing) && (rxfactory.operator->() != factory)) { - filters.push_back(PCREFilter(re, reason, type, duration, freeform, flags)); - return std::make_pair(true, ""); + ServerInstance->SNO->WriteToSnoMask('a', "Regex engine has changed, removing all R-lines."); + ServerInstance->XLines->DelAll(f.GetType()); } + + initing = false; } - virtual void OnRehash(User* user, const std::string ¶meter) - { - ConfigReader MyConf(ServerInstance); + ModResult OnStats(Stats::Context& stats) CXX11_OVERRIDE + { + if (stats.GetSymbol() != 'R') + return MOD_RES_PASSTHRU; - for (int index = 0; index < MyConf.Enumerate("keyword"); index++) - { - this->DeleteFilter(MyConf.ReadValue("keyword", "pattern", index)); + ServerInstance->XLines->InvokeStats("R", stats); + return MOD_RES_DENY; + } - 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 = "*"; + void OnUserPostNick(User *user, const std::string &oldnick) CXX11_OVERRIDE + { + if (!IS_LOCAL(user)) + return; - re = pcre_compile(pattern.c_str(),0,&error,&erroffset,NULL); + if (!MatchOnNickChange) + 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 - { - filters.push_back(PCREFilter(re, reason, action, gline_time, pattern, flags)); - ServerInstance->Log(DEFAULT,"Regular expression %s loaded.", pattern.c_str()); - } + XLine *rl = ServerInstance->XLines->MatchesLine("R", user); + + if (rl) + { + // Bang! :D + rl->Apply(user); } } - virtual int OnStats(char symbol, User* user, string_list &results) + void OnBackgroundTimer(time_t curtime) CXX11_OVERRIDE { - if (symbol == 's') + if (added_zline) { - std::string sn = ServerInstance->Config->ServerName; - for (std::vector::iterator i = filters.begin(); i != filters.end(); i++) - { - results.push_back(sn+" 223 "+user->nick+" :REGEXP:"+i->freeform+" "+i->flags+" "+i->action+" "+ConvToStr(i->gline_time)+" :"+i->reason); - } + added_zline = false; + ServerInstance->XLines->ApplyLines(); + } + } + + void OnUnloadModule(Module* mod) CXX11_OVERRIDE + { + // If the regex engine became unavailable or has changed, remove all R-lines. + if (!rxfactory) + { + ServerInstance->XLines->DelAll(f.GetType()); + } + else if (rxfactory.operator->() != factory) + { + factory = rxfactory.operator->(); + ServerInstance->XLines->DelAll(f.GetType()); } - return 0; } -}; -MODULE_INIT(ModuleFilterPCRE) + void Prioritize() CXX11_OVERRIDE + { + Module* mod = ServerInstance->Modules->Find("m_cgiirc.so"); + ServerInstance->Modules->SetPriority(this, I_OnUserRegister, PRIORITY_AFTER, mod); + } +}; +MODULE_INIT(ModuleRLine)