X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_shun.cpp;h=5db3c8ef743cf2d01397dfe6d29c4c3e925be88f;hb=21e7efdadfa685ac1ddcb0a0a515502bc873302b;hp=509ed3ae1be528aa12497531f1d90fd0e2cd2794;hpb=e9b343457de271771c181a288aaa3e34bd397850;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_shun.cpp b/src/modules/m_shun.cpp index 509ed3ae1..e54156da6 100644 --- a/src/modules/m_shun.cpp +++ b/src/modules/m_shun.cpp @@ -1,216 +1,252 @@ -#include -#include -#include -#include -#include "inspircd.h" -#include "modules.h" -#include "hashcomp.h" -#include "configreader.h" -#include "xline.h" - -/* $ModDesc: Provides the /shun command, which stops a user executing all commands except PING and PONG. */ - -class Shun : public XLine -{ -public: - std::string matchtext; - - Shun(InspIRCd* Instance, time_t s_time, long d, const char* src, const char* re, const char *shunmask) : XLine(Instance, s_time, d, src, re, "SHUN") - { - this->matchtext = shunmask; - } - - ~Shun() - { - } - - bool Matches(User *u) - { - if (ServerInstance->MatchText(u->GetFullHost(), matchtext) || ServerInstance->MatchText(u->GetFullRealHost(), matchtext)) - return true; - - return false; - } - - bool Matches(const std::string &s) - { - if (matchtext == s) - return true; - return false; - } +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2008 Craig Edwards + * Copyright (C) 2008 Thomas Stagner + * + * 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 . + */ - void Apply(User *u) - { - // Application is done by the module. - } +#include "inspircd.h" +#include "xline.h" +#include "modules/shun.h" +#include "modules/stats.h" - void DisplayExpiry() - { - ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed shun %s (set by %s %ld seconds ago)", this->matchtext.c_str(), this->source, this->duration); - } - - const char* Displayable() - { - return matchtext.c_str(); - } -}; /** An XLineFactory specialized to generate shun pointers */ class ShunFactory : public XLineFactory { public: - ShunFactory(InspIRCd* Instance) : XLineFactory(Instance, "SHUN") { } + ShunFactory() : XLineFactory("SHUN") { } /** Generate a shun */ - XLine* Generate(time_t set_time, long duration, const char* source, const char* reason, const char* 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(ServerInstance, set_time, duration, source, reason, xline_specific_mask); + return new Shun(set_time, duration, source, reason, xline_specific_mask); } - virtual bool AutoApplyToUserList(XLine*) + bool AutoApplyToUserList(XLine* x) CXX11_OVERRIDE { - // No, we don't want to be applied to users automagically. return false; } }; //typedef std::vector shunlist; -class cmd_shun : public Command +class CommandShun : public Command { - private: - InspIRCd *Srv; - public: - cmd_shun(InspIRCd* Me) : Command(Me, "SHUN", "o", 1), Srv(Me) + CommandShun(Module* Creator) : Command(Creator, "SHUN", 1, 3) { - this->source = "m_shun.so"; + flags_needed = 'o'; this->syntax = " [ :]"; } - CmdResult Handle(const char* const*parameters, int pcnt, 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. */ - if(pcnt == 1) + std::string target = parameters[0]; + + User *find = ServerInstance->FindNick(target); + if ((find) && (find->registered == REG_ALL)) + target = std::string("*!*@") + find->GetIPString(); + + if (parameters.size() == 1) { - if (ServerInstance->XLines->DelLine(parameters[0], "S", user)) + std::string reason; + + if (ServerInstance->XLines->DelLine(parameters[0].c_str(), "SHUN", reason, user)) + { + 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.",user->nick,parameters[0]); + ServerInstance->SNO->WriteToSnoMask('x', "%s removed SHUN on %s: %s", user->nick.c_str(), target.c_str(), reason.c_str()); } else { - // XXX todo implement stats - user->WriteServ("NOTICE %s :*** Shun %s not found in list, try /stats s.",user->nick,parameters[0]); + user->WriteNotice("*** Shun " + parameters[0] + " not found in list, try /stats H."); + return CMD_FAILURE; } - - return CMD_SUCCESS; } - else if (pcnt >= 2) + else { // Adding - XXX todo make this respect tag perhaps.. - long duration = ServerInstance->Duration(parameters[1]); - Shun *r = NULL; - - try + unsigned long duration; + std::string expr; + if (parameters.size() > 2) { - r = new Shun(ServerInstance, ServerInstance->Time(), duration, user->nick, parameters[2], parameters[0]); + if (!InspIRCd::Duration(parameters[1], duration)) + { + user->WriteNotice("*** Invalid duration for SHUN."); + return CMD_FAILURE; + } + expr = parameters[2]; } - catch (...) + else { - ; // Do nothing. If we get here, the regex was fucked up, and they already got told it fucked up. + duration = 0; + expr = parameters[1]; } - if (r) + Shun* r = new Shun(ServerInstance->Time(), duration, user->nick.c_str(), expr.c_str(), target.c_str()); + if (ServerInstance->XLines->AddLine(r, user)) { - if (ServerInstance->XLines->AddLine(r, user)) + if (!duration) { - if (!duration) - { - ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent shun for %s.", user->nick, parameters[0]); - } - else - { - time_t c_requires_crap = duration + ServerInstance->Time(); - ServerInstance->SNO->WriteToSnoMask('x', "%s added timed shun for %s, expires on %s", user->nick, parameters[0], - ServerInstance->TimeString(c_requires_crap).c_str()); - } - - ServerInstance->XLines->ApplyLines(); + ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent SHUN for %s: %s", + user->nick.c_str(), target.c_str(), expr.c_str()); } else { - delete r; - user->WriteServ("NOTICE %s :*** Shun for %s already exists", user->nick, parameters[0]); + 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()); } } + else + { + delete r; + user->WriteNotice("*** Shun for " + target + " already exists."); + return CMD_FAILURE; + } } + return CMD_SUCCESS; + } + + RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE + { + if (IS_LOCAL(user)) + return ROUTE_LOCALONLY; // spanningtree will send ADDLINE - return CMD_FAILURE; + return ROUTE_BROADCAST; } }; -class ModuleShun : public Module +class ModuleShun : public Module, public Stats::EventListener { - cmd_shun* mycommand; - ShunFactory *f; + CommandShun cmd; + ShunFactory f; + insp::flat_set ShunEnabledCommands; + bool NotifyOfShun; + bool affectopers; public: - ModuleShun(InspIRCd* Me) : Module(Me) + ModuleShun() + : Stats::EventListener(this) + , cmd(this) { - f = new ShunFactory(ServerInstance); - ServerInstance->XLines->RegisterFactory(f); + } - mycommand = new cmd_shun(ServerInstance); - ServerInstance->AddCommand(mycommand); + void init() CXX11_OVERRIDE + { + ServerInstance->XLines->RegisterFactory(&f); } - virtual ~ModuleShun() + ~ModuleShun() { - ServerInstance->XLines->UnregisterFactory(f); + ServerInstance->XLines->DelAll("SHUN"); + ServerInstance->XLines->UnregisterFactory(&f); } - void Implements(char* List) + void Prioritize() CXX11_OVERRIDE { - List[I_OnPreCommand] = List[I_OnStats] = 1; + Module* alias = ServerInstance->Modules->Find("m_alias.so"); + ServerInstance->Modules->SetPriority(this, I_OnPreCommand, PRIORITY_BEFORE, alias); } - - virtual int OnStats(char symbol, User* user, string_list& out) + + ModResult OnStats(Stats::Context& stats) CXX11_OVERRIDE { - // XXX write me -//format << Srv->Config->ServerName << " 223 " << user->nick << " :" << iter->banmask << " " << iter->set_on << " " << iter->length << " " << -//iter->set_by << " " << iter->reason; - - return 0; + if (stats.GetSymbol() != 'H') + return MOD_RES_PASSTHRU; + + ServerInstance->XLines->InvokeStats("SHUN", 223, stats); + return MOD_RES_DENY; } - virtual int OnPreCommand(const std::string &command, const char* const*parameters, int pcnt, User* user, bool validated, const std::string &original_line) + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { - if (user->registered != REG_ALL) - return 0; + 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"; - if((command != "PONG") && (command != "PING")) + ShunEnabledCommands.clear(); + + irc::spacesepstream dcmds(cmds); + std::string thiscmd; + + while (dcmds.GetToken(thiscmd)) { - // Don't let them issue cmd if they are shunned.. - XLine *rl = ServerInstance->XLines->MatchesLine("S", user); + ShunEnabledCommands.insert(thiscmd); + } - if (rl) - { - return 1; - } + NotifyOfShun = tag->getBool("notifyuser", true); + affectopers = tag->getBool("affectopers", false); + } + + 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 */ + return MOD_RES_PASSTHRU; } - return 0; + if (!ShunEnabledCommands.count(command)) + { + if (NotifyOfShun) + user->WriteNotice("*** Command " + command + " not processed, as you have been blocked from issuing commands (SHUN)"); + return MOD_RES_DENY; + } + + if (command == "QUIT") + { + /* Allow QUIT but dont show any quit message */ + parameters.clear(); + } + else if ((command == "PART") && (parameters.size() > 1)) + { + /* same for PART */ + parameters.pop_back(); + } + + /* if we're here, allow the command. */ + return MOD_RES_PASSTHRU; } - virtual Version GetVersion() + Version GetVersion() CXX11_OVERRIDE { - return Version(1,0,0,0,0,API_VERSION); + return Version("Provides the /SHUN command, which stops a user from executing all except configured commands.",VF_VENDOR|VF_COMMON); } }; MODULE_INIT(ModuleShun) -