X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_shun.cpp;h=c68afc494491177ced33e0bfa8de8bdc24d958a7;hb=HEAD;hp=02272652439e4316b23d86cd065140755ebbc2bd;hpb=926361d233f4e6ea6a3964a070097fe637bd6bed;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_shun.cpp b/src/modules/m_shun.cpp index 022726524..c68afc494 100644 --- a/src/modules/m_shun.cpp +++ b/src/modules/m_shun.cpp @@ -1,10 +1,19 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2019 Matt Schatz + * Copyright (C) 2018 linuxdaemon + * Copyright (C) 2017-2018 B00mX0r + * Copyright (C) 2013, 2017-2018, 2020-2021 Sadie Powell + * Copyright (C) 2012-2013, 2015-2016 Attila Molnar + * Copyright (C) 2012, 2019 Robby + * Copyright (C) 2012 Jens Voss + * Copyright (C) 2009 Uli Schlachter + * Copyright (C) 2009 Dennis Friis * Copyright (C) 2009 Daniel De Graaf - * Copyright (C) 2008 Robin Burchell - * Copyright (C) 2008 Craig Edwards + * Copyright (C) 2008-2010 Craig Edwards * Copyright (C) 2008 Thomas Stagner + * Copyright (C) 2008 Robin Burchell * * 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 @@ -22,46 +31,9 @@ #include "inspircd.h" #include "xline.h" +#include "modules/shun.h" +#include "modules/stats.h" -class Shun : public XLine -{ -public: - std::string matchtext; - - Shun(time_t s_time, long d, const std::string& src, const std::string& re, const std::string& shunmask) - : XLine(s_time, d, src, re, "SHUN") - , matchtext(shunmask) - { - } - - bool Matches(User *u) - { - // E: overrides shun - LocalUser* lu = IS_LOCAL(u); - if (lu && lu->exempt) - return false; - - if (InspIRCd::Match(u->GetFullHost(), matchtext) || InspIRCd::Match(u->GetFullRealHost(), matchtext) || InspIRCd::Match(u->nick+"!"+u->ident+"@"+u->GetIPString(), matchtext)) - return true; - - if (InspIRCd::MatchCIDR(u->GetIPString(), matchtext, ascii_case_insensitive_map)) - return true; - - return false; - } - - bool Matches(const std::string &s) - { - if (matchtext == s) - return true; - return false; - } - - const std::string& Displayable() - { - return matchtext; - } -}; /** An XLineFactory specialized to generate shun pointers */ @@ -71,29 +43,28 @@ class ShunFactory : public XLineFactory ShunFactory() : XLineFactory("SHUN") { } /** Generate a shun - */ - XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) + */ + 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 { return new Shun(set_time, duration, source, reason, xline_specific_mask); } - bool AutoApplyToUserList(XLine *x) + bool AutoApplyToUserList(XLine* x) CXX11_OVERRIDE { return false; } }; -//typedef std::vector shunlist; - class CommandShun : public Command { public: CommandShun(Module* Creator) : Command(Creator, "SHUN", 1, 3) { - flags_needed = 'o'; this->syntax = " [] :"; + flags_needed = 'o'; + syntax = " [ :]"; } - CmdResult Handle(const std::vector& parameters, User *user) + CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE { /* syntax: SHUN nick!user@host time :reason goes here */ /* 'time' is a human-readable timestring, like 2d3h2s. */ @@ -106,13 +77,19 @@ class CommandShun : public Command if (parameters.size() == 1) { - if (ServerInstance->XLines->DelLine(target.c_str(), "SHUN", user)) + std::string reason; + + if (ServerInstance->XLines->DelLine(parameters[0].c_str(), "SHUN", reason, user)) { - ServerInstance->SNO->WriteToSnoMask('x',"%s removed SHUN on %s",user->nick.c_str(),target.c_str()); + ServerInstance->SNO->WriteToSnoMask('x', "%s removed SHUN on %s: %s", user->nick.c_str(), parameters[0].c_str(), reason.c_str()); + } + else if (ServerInstance->XLines->DelLine(target.c_str(), "SHUN", reason, user)) + { + ServerInstance->SNO->WriteToSnoMask('x', "%s removed SHUN on %s: %s", user->nick.c_str(), target.c_str(), reason.c_str()); } else { - user->WriteNotice("*** Shun " + target + " not found in list, try /stats H."); + user->WriteNotice("*** Shun " + parameters[0] + " not found on the list."); return CMD_FAILURE; } } @@ -123,7 +100,11 @@ class CommandShun : public Command std::string expr; if (parameters.size() > 2) { - duration = InspIRCd::Duration(parameters[1]); + if (!InspIRCd::Duration(parameters[1], duration)) + { + user->WriteNotice("*** Invalid duration for SHUN."); + return CMD_FAILURE; + } expr = parameters[2]; } else @@ -137,28 +118,27 @@ class CommandShun : public Command { if (!duration) { - ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent SHUN for %s: %s", + ServerInstance->SNO->WriteToSnoMask('x', "%s added permanent SHUN for %s: %s", user->nick.c_str(), target.c_str(), expr.c_str()); } else { - time_t c_requires_crap = duration + ServerInstance->Time(); - std::string timestr = InspIRCd::TimeString(c_requires_crap); - ServerInstance->SNO->WriteToSnoMask('x', "%s added timed SHUN for %s to expire on %s: %s", - user->nick.c_str(), target.c_str(), timestr.c_str(), expr.c_str()); + ServerInstance->SNO->WriteToSnoMask('x', "%s added timed SHUN for %s, expires in %s (on %s): %s", + user->nick.c_str(), target.c_str(), InspIRCd::DurationString(duration).c_str(), + InspIRCd::TimeString(ServerInstance->Time() + duration).c_str(), expr.c_str()); } } else { delete r; - user->WriteNotice("*** Shun for " + target + " already exists"); + user->WriteNotice("*** Shun for " + target + " already exists."); return CMD_FAILURE; } } return CMD_SUCCESS; } - RouteDescriptor GetRouting(User* user, const std::vector& parameters) + RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { if (IS_LOCAL(user)) return ROUTE_LOCALONLY; // spanningtree will send ADDLINE @@ -167,31 +147,55 @@ class CommandShun : public Command } }; -class ModuleShun : public Module +class ModuleShun : public Module, public Stats::EventListener { + private: CommandShun cmd; - ShunFactory f; - insp::flat_set ShunEnabledCommands; - bool NotifyOfShun; + ShunFactory shun; + insp::flat_set cleanedcommands; + insp::flat_set enabledcommands; bool affectopers; + bool allowconnect; + bool allowtags; + bool notifyuser; + + bool IsShunned(LocalUser* user) + { + // Exempt the user if they are not fully connected and allowconnect is enabled. + if (allowconnect && user->registered != REG_ALL) + return false; + + // Exempt the user from shuns if they are an oper and affectopers is disabled. + if (!affectopers && user->IsOper()) + return false; + + // Exempt the user from shuns if they are an oper with the servers/ignore-shun privilege. + if (user->HasPrivPermission("servers/ignore-shun")) + return false; + + // Check whether the user is actually shunned. + return ServerInstance->XLines->MatchesLine("SHUN", user); + } public: - ModuleShun() : cmd(this) + ModuleShun() + : Stats::EventListener(this) + , cmd(this) { } void init() CXX11_OVERRIDE { - ServerInstance->XLines->RegisterFactory(&f); + ServerInstance->XLines->RegisterFactory(&shun); } ~ModuleShun() { ServerInstance->XLines->DelAll("SHUN"); - ServerInstance->XLines->UnregisterFactory(&f); + ServerInstance->XLines->UnregisterFactory(&shun); } - void Prioritize() + void Prioritize() CXX11_OVERRIDE { Module* alias = ServerInstance->Modules->Find("m_alias.so"); ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias); @@ -202,75 +206,80 @@ class ModuleShun : public Module if (stats.GetSymbol() != 'H') return MOD_RES_PASSTHRU; - ServerInstance->XLines->InvokeStats("SHUN", 223, stats); + ServerInstance->XLines->InvokeStats("SHUN", stats); return MOD_RES_DENY; } void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { ConfigTag* tag = ServerInstance->Config->ConfValue("shun"); - std::string cmds = tag->getString("enabledcommands"); - std::transform(cmds.begin(), cmds.end(), cmds.begin(), ::toupper); - - if (cmds.empty()) - cmds = "PING PONG QUIT"; - ShunEnabledCommands.clear(); + cleanedcommands.clear(); + irc::spacesepstream cleanedcmds(tag->getString("cleanedcommands", "AWAY PART QUIT")); + for (std::string cleanedcmd; cleanedcmds.GetToken(cleanedcmd); ) + cleanedcommands.insert(cleanedcmd); - std::stringstream dcmds(cmds); - std::string thiscmd; + enabledcommands.clear(); + irc::spacesepstream enabledcmds(tag->getString("enabledcommands", "ADMIN OPER PING PONG QUIT", 1)); + for (std::string enabledcmd; enabledcmds.GetToken(enabledcmd); ) + enabledcommands.insert(enabledcmd); - while (dcmds >> thiscmd) - { - ShunEnabledCommands.insert(thiscmd); - } - - NotifyOfShun = tag->getBool("notifyuser", true); affectopers = tag->getBool("affectopers", false); + allowtags = tag->getBool("allowtags"); + allowconnect = tag->getBool("allowconnect"); + notifyuser = tag->getBool("notifyuser", true); } - ModResult OnPreCommand(std::string &command, std::vector& parameters, LocalUser* user, bool validated, const std::string &original_line) CXX11_OVERRIDE + ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) CXX11_OVERRIDE { - if (validated) - return MOD_RES_PASSTHRU; - - if (!ServerInstance->XLines->MatchesLine("SHUN", user)) - { - /* Not shunned, don't touch. */ - return MOD_RES_PASSTHRU; - } - - if (!affectopers && user->IsOper()) - { - /* Don't do anything if the user is an operator and affectopers isn't set */ + if (validated || !IsShunned(user)) return MOD_RES_PASSTHRU; - } - if (!ShunEnabledCommands.count(command)) + if (!enabledcommands.count(command)) { - if (NotifyOfShun) - user->WriteNotice("*** Command " + command + " not processed, as you have been blocked from issuing commands (SHUN)"); + if (notifyuser) + user->WriteNotice("*** " + command + " command not processed as you have been blocked from issuing commands."); return MOD_RES_DENY; } - if (command == "QUIT") + if (!allowtags) { - /* Allow QUIT but dont show any quit message */ - parameters.clear(); + // Remove all client tags. + ClientProtocol::TagMap& tags = parameters.GetTags(); + for (ClientProtocol::TagMap::iterator tag = tags.begin(); tag != tags.end(); ) + { + if (tag->first[0] == '+') + tag = tags.erase(tag); + else + tag++; + } } - else if ((command == "PART") && (parameters.size() > 1)) + + if (cleanedcommands.count(command)) { - /* same for PART */ - parameters[1].clear(); + if (command == "AWAY" && !parameters.empty()) + { + // Allow away but only for unsetting. + parameters.clear(); + } + else if (command == "PART" && parameters.size() > 1) + { + // Allow part but strip the message. + parameters.pop_back(); + } + else if (command == "QUIT" && !parameters.empty()) + { + // Allow quit but strip the message. + parameters.clear(); + } } - /* if we're here, allow the command. */ return MOD_RES_PASSTHRU; } Version GetVersion() CXX11_OVERRIDE { - return Version("Provides the /SHUN command, which stops a user from executing all except configured commands.",VF_VENDOR|VF_COMMON); + return Version("Adds the /SHUN command which allows server operators to prevent users from executing commands.", VF_VENDOR|VF_COMMON); } };