X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_silence.cpp;h=e7271e68fc71262339f85a6990515ca4adeef618;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=502f947f45b0f4f442af00ef30e574ddc8934c5b;hpb=9b99c5ad31eb8de222d2b3aa1daa9412f0b25857;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_silence.cpp b/src/modules/m_silence.cpp index 502f947f4..e7271e68f 100644 --- a/src/modules/m_silence.cpp +++ b/src/modules/m_silence.cpp @@ -1,11 +1,10 @@ /* * InspIRCd -- Internet Relay Chat Daemon * - * Copyright (C) 2009-2010 Daniel De Graaf - * Copyright (C) 2006-2008 Robin Burchell - * Copyright (C) 2007 Dennis Friis - * Copyright (C) 2005-2007 Craig Edwards - * Copyright (C) 2006 John Brooks + * Copyright (C) 2019 linuxdaemon + * Copyright (C) 2019 iwalkalone + * Copyright (C) 2019 Sadie Powell + * Copyright (C) 2019 Robby * * 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,358 +21,502 @@ #include "inspircd.h" +#include "modules/ctctags.h" -/* Improved drop-in replacement for the /SILENCE command - * syntax: /SILENCE [+|-] as in - * - * example that blocks all except private messages - * /SILENCE +*!*@* a - * /SILENCE +*!*@* px - * - * example that blocks all invites except from channel services - * /SILENCE +*!*@* i - * /SILENCE +chanserv!services@chatters.net ix - * - * example that blocks some bad dude from private, notice and inviting you - * /SILENCE +*!kiddie@lamerz.net pin - * - * TODO: possibly have add and remove check for existing host and only modify flags according to - * what's been changed instead of having to remove first, then add if you want to change - * an entry. - */ +enum +{ + // From ircu? + RPL_SILELIST = 271, + RPL_ENDOFSILELIST = 272, + ERR_SILELISTFULL = 511, -// pair of hostmask and flags -typedef std::pair silenceset; + // InspIRCd-specific. + ERR_SILENCE = 952 +}; -// deque list of pairs -typedef std::deque silencelist; +class SilenceEntry +{ + public: + enum SilenceFlags + { + // Does nothing; for internal use only. + SF_NONE = 0, -// intmasks for flags -static int SILENCE_PRIVATE = 0x0001; /* p private messages */ -static int SILENCE_CHANNEL = 0x0002; /* c channel messages */ -static int SILENCE_INVITE = 0x0004; /* i invites */ -static int SILENCE_NOTICE = 0x0008; /* n notices */ -static int SILENCE_CNOTICE = 0x0010; /* t channel notices */ -static int SILENCE_ALL = 0x0020; /* a all, (pcint) */ -static int SILENCE_EXCLUDE = 0x0040; /* x exclude this pattern */ + // Exclude users who match this flags ("x"). + SF_EXEMPT = 1, + // 2, 4, 8, 16 are reserved for future use. -class CommandSVSSilence : public Command -{ - public: - CommandSVSSilence(Module* Creator) : Command(Creator,"SVSSILENCE", 2) + // Matches a NOTICE targeted at a channel ("n"). + SF_NOTICE_CHANNEL = 32, + + // Matches a NOTICE targeted at a user ("N"). + SF_NOTICE_USER = 64, + + // Matches a PRIVMSG targeted at a channel ("p"). + SF_PRIVMSG_CHANNEL = 128, + + // Matches a PRIVMSG targeted at a user ("P"). + SF_PRIVMSG_USER = 256, + + // Matches a TAGMSG targeted at a channel ("t"). + SF_TAGMSG_CHANNEL = 512, + + // Matches a TAGMSG targeted at a user ("T"). + SF_TAGMSG_USER = 1024, + + // Matches a CTCP targeted at a channel ("c"). + SF_CTCP_CHANNEL = 2048, + + // Matches a CTCP targeted at a user ("C"). + SF_CTCP_USER = 4096, + + // Matches an invite to a channel ("i"). + SF_INVITE = 8192, + + // The default if no flags have been specified. + SF_DEFAULT = SF_NOTICE_CHANNEL | SF_NOTICE_USER | SF_PRIVMSG_CHANNEL | SF_PRIVMSG_USER | SF_TAGMSG_CHANNEL | + SF_TAGMSG_USER | SF_CTCP_CHANNEL | SF_CTCP_USER | SF_INVITE + }; + + // The flags that this mask is silenced for. + uint32_t flags; + + // The mask which is silenced (e.g. *!*@example.com). + std::string mask; + + SilenceEntry(uint32_t Flags, const std::string& Mask) + : flags(Flags) + , mask(Mask) { - syntax = " {[+|-] }"; - TRANSLATE3(TR_NICK, TR_TEXT, TR_TEXT); } - CmdResult Handle (const std::vector& parameters, User *user) + bool operator <(const SilenceEntry& other) const { - /* - * XXX: thought occurs to me - * We may want to change the syntax of this command to - * SVSSILENCE + - + - * style command so services can modify lots of entries at once. - * leaving it backwards compatible for now as it's late. -- w - */ - if (!user->server->IsULine()) - return CMD_FAILURE; - - User *u = ServerInstance->FindNick(parameters[0]); - if (!u) - return CMD_FAILURE; + if (flags & SF_EXEMPT && other.flags & ~SF_EXEMPT) + return true; + if (other.flags & SF_EXEMPT && flags & ~SF_EXEMPT) + return false; + if (flags < other.flags) + return true; + if (other.flags < flags) + return false; + return mask < other.mask; + } - if (IS_LOCAL(u)) + // Converts a flag list to a bitmask. + static bool FlagsToBits(const std::string& flags, uint32_t& out) + { + out = SF_NONE; + for (std::string::const_iterator flag = flags.begin(); flag != flags.end(); ++flag) { - ServerInstance->Parser.CallHandler("SILENCE", std::vector(parameters.begin() + 1, parameters.end()), u); + switch (*flag) + { + case 'C': + out |= SF_CTCP_USER; + break; + case 'c': + out |= SF_CTCP_CHANNEL; + break; + case 'd': + out |= SF_DEFAULT; + break; + case 'i': + out |= SF_INVITE; + break; + case 'N': + out |= SF_NOTICE_USER; + break; + case 'n': + out |= SF_NOTICE_CHANNEL; + break; + case 'P': + out |= SF_PRIVMSG_USER; + break; + case 'p': + out |= SF_PRIVMSG_CHANNEL; + break; + case 'T': + out |= SF_TAGMSG_USER; + break; + case 't': + out |= SF_TAGMSG_CHANNEL; + break; + case 'x': + out |= SF_EXEMPT; + break; + default: + out = SF_NONE; + return false; + } } - - return CMD_SUCCESS; + return true; } - RouteDescriptor GetRouting(User* user, const std::vector& parameters) + // Converts a bitmask to a flag list. + static std::string BitsToFlags(uint32_t flags) { - User* target = ServerInstance->FindNick(parameters[0]); - if (target) - return ROUTE_OPT_UCAST(target->server); - return ROUTE_LOCALONLY; + std::string out; + if (flags & SF_CTCP_USER) + out.push_back('C'); + if (flags & SF_CTCP_CHANNEL) + out.push_back('c'); + if (flags & SF_INVITE) + out.push_back('i'); + if (flags & SF_NOTICE_USER) + out.push_back('N'); + if (flags & SF_NOTICE_CHANNEL) + out.push_back('n'); + if (flags & SF_PRIVMSG_USER) + out.push_back('P'); + if (flags & SF_PRIVMSG_CHANNEL) + out.push_back('p'); + if (flags & SF_TAGMSG_CHANNEL) + out.push_back('T'); + if (flags & SF_TAGMSG_USER) + out.push_back('t'); + if (flags & SF_EXEMPT) + out.push_back('x'); + return out; } }; -class CommandSilence : public Command +typedef insp::flat_set SilenceList; + +class SilenceExtItem : public SimpleExtItem { - unsigned int& maxsilence; public: - SimpleExtItem ext; - CommandSilence(Module* Creator, unsigned int &max) : Command(Creator, "SILENCE", 0), - maxsilence(max) - , ext("silence_list", ExtensionItem::EXT_USER, Creator) + unsigned int maxsilence; + + SilenceExtItem(Module* Creator) + : SimpleExtItem("silence_list", ExtensionItem::EXT_USER, Creator) { - allow_empty_last_param = false; - syntax = "{[+|-] }"; } - CmdResult Handle (const std::vector& parameters, User *user) + void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE { - if (!parameters.size()) - { - // no parameters, show the current silence list. - silencelist* sl = ext.get(user); - // if the user has a silence list associated with their user record, show it - if (sl) - { - for (silencelist::const_iterator c = sl->begin(); c != sl->end(); c++) - { - std::string decomppattern = DecompPattern(c->second); - user->WriteNumeric(271, "%s %s %s", user->nick.c_str(),c->first.c_str(), decomppattern.c_str()); - } - } - user->WriteNumeric(272, ":End of Silence List"); + LocalUser* user = IS_LOCAL(static_cast(container)); + if (!user) + return; - return CMD_SUCCESS; - } - else if (parameters.size() > 0) + // Remove the old list and create a new one. + unset(user); + SilenceList* list = new SilenceList(); + + irc::spacesepstream ts(value); + while (!ts.StreamEnd()) { - // one or more parameters, add or delete entry from the list (only the first parameter is used) - std::string mask(parameters[0], 1); - char action = parameters[0][0]; - // Default is private and notice so clients do not break - int pattern = CompilePattern("pn"); - - // if pattern supplied, use it - if (parameters.size() > 1) { - pattern = CompilePattern(parameters[1].c_str()); + // Check we have space for another entry. + if (list->size() >= maxsilence) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Oversized silence list received for %s: %s", + user->uuid.c_str(), value.c_str()); + delete list; + return; } - if (pattern == 0) + // Extract the mask and the flags. + std::string mask; + std::string flagstr; + if (!ts.GetToken(mask) || !ts.GetToken(flagstr)) { - user->WriteNotice("Bad SILENCE pattern"); - return CMD_INVALID; + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Malformed silence list received for %s: %s", + user->uuid.c_str(), value.c_str()); + delete list; + return; } - if (!mask.length()) + // Try to parse the flags. + uint32_t flags; + if (!SilenceEntry::FlagsToBits(flagstr, flags)) { - // 'SILENCE +' or 'SILENCE -', assume *!*@* - mask = "*!*@*"; + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Malformed silence flags received for %s: %s", + user->uuid.c_str(), flagstr.c_str()); + delete list; + return; } - ModeParser::CleanMask(mask); + // Store the silence entry. + list->insert(SilenceEntry(flags, mask)); + } - if (action == '-') - { - std::string decomppattern = DecompPattern(pattern); - // fetch their silence list - silencelist* sl = ext.get(user); - // does it contain any entries and does it exist? - if (sl) - { - for (silencelist::iterator i = sl->begin(); i != sl->end(); i++) - { - // search through for the item - irc::string listitem = i->first.c_str(); - if (listitem == mask && i->second == pattern) - { - sl->erase(i); - user->WriteNumeric(950, "%s :Removed %s %s from silence list", user->nick.c_str(), mask.c_str(), decomppattern.c_str()); - if (!sl->size()) - { - ext.unset(user); - } - return CMD_SUCCESS; - } - } - } - user->WriteNumeric(952, "%s :%s %s does not exist on your silence list", user->nick.c_str(), mask.c_str(), decomppattern.c_str()); - } - else if (action == '+') + // The value was well formed. + set(user, list); + } + + std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE + { + SilenceList* list = static_cast(item); + std::string buf; + for (SilenceList::const_iterator iter = list->begin(); iter != list->end(); ++iter) + { + if (iter != list->begin()) + buf.push_back(' '); + + buf.append(iter->mask); + buf.push_back(' '); + buf.append(SilenceEntry::BitsToFlags(iter->flags)); + } + return buf; + } +}; + +class SilenceMessage : public ClientProtocol::Message +{ + public: + SilenceMessage(const std::string& mask, const std::string& flags) + : ClientProtocol::Message("SILENCE") + { + PushParam(mask); + PushParam(flags); + } +}; + +class CommandSilence : public SplitCommand +{ + private: + ClientProtocol::EventProvider msgprov; + + CmdResult AddSilence(LocalUser* user, const std::string& mask, uint32_t flags) + { + SilenceList* list = ext.get(user); + if (list && list->size() > ext.maxsilence) + { + user->WriteNumeric(ERR_SILELISTFULL, mask, SilenceEntry::BitsToFlags(flags), "Your SILENCE list is full"); + return CMD_FAILURE; + } + else if (!list) + { + // There is no list; create it. + list = new SilenceList(); + ext.set(user, list); + } + + if (!list->insert(SilenceEntry(flags, mask)).second) + { + user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified already exists"); + return CMD_FAILURE; + } + + SilenceMessage msg("+" + mask, SilenceEntry::BitsToFlags(flags)); + user->Send(msgprov, msg); + return CMD_SUCCESS; + } + + CmdResult RemoveSilence(LocalUser* user, const std::string& mask, uint32_t flags) + { + SilenceList* list = ext.get(user); + if (list) + { + for (SilenceList::iterator iter = list->begin(); iter != list->end(); ++iter) { - // fetch the user's current silence list - silencelist* sl = ext.get(user); - if (!sl) - { - sl = new silencelist; - ext.set(user, sl); - } - if (sl->size() > maxsilence) - { - user->WriteNumeric(952, "%s :Your silence list is full",user->nick.c_str()); - return CMD_FAILURE; - } + if (!irc::equals(iter->mask, mask) || iter->flags != flags) + continue; - std::string decomppattern = DecompPattern(pattern); - for (silencelist::iterator n = sl->begin(); n != sl->end(); n++) - { - irc::string listitem = n->first.c_str(); - if (listitem == mask && n->second == pattern) - { - user->WriteNumeric(952, "%s :%s %s is already on your silence list", user->nick.c_str(), mask.c_str(), decomppattern.c_str()); - return CMD_FAILURE; - } - } - if (((pattern & SILENCE_EXCLUDE) > 0)) - { - sl->push_front(silenceset(mask,pattern)); - } - else - { - sl->push_back(silenceset(mask,pattern)); - } - user->WriteNumeric(951, "%s :Added %s %s to silence list", user->nick.c_str(), mask.c_str(), decomppattern.c_str()); + list->erase(iter); + SilenceMessage msg("-" + mask, SilenceEntry::BitsToFlags(flags)); + user->Send(msgprov, msg); return CMD_SUCCESS; } } - return CMD_SUCCESS; + + user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified could not be found"); + return CMD_FAILURE; } - /* turn the nice human readable pattern into a mask */ - int CompilePattern(const char* pattern) + CmdResult ShowSilenceList(LocalUser* user) { - int p = 0; - for (const char* n = pattern; *n; n++) + SilenceList* list = ext.get(user); + if (list) { - switch (*n) + for (SilenceList::const_iterator iter = list->begin(); iter != list->end(); ++iter) { - case 'p': - p |= SILENCE_PRIVATE; - break; - case 'c': - p |= SILENCE_CHANNEL; - break; - case 'i': - p |= SILENCE_INVITE; - break; - case 'n': - p |= SILENCE_NOTICE; - break; - case 't': - p |= SILENCE_CNOTICE; - break; - case 'a': - case '*': - p |= SILENCE_ALL; - break; - case 'x': - p |= SILENCE_EXCLUDE; - break; - default: - break; + user->WriteNumeric(RPL_SILELIST, iter->mask, SilenceEntry::BitsToFlags(iter->flags)); } } - return p; + user->WriteNumeric(RPL_ENDOFSILELIST, "End of SILENCE list"); + return CMD_SUCCESS; } - /* turn the mask into a nice human readable format */ - std::string DecompPattern (const int pattern) + public: + SilenceExtItem ext; + + CommandSilence(Module* Creator) + : SplitCommand(Creator, "SILENCE") + , msgprov(Creator, "SILENCE") + , ext(Creator) { - std::string out; - if (pattern & SILENCE_PRIVATE) - out += ",privatemessages"; - if (pattern & SILENCE_CHANNEL) - out += ",channelmessages"; - if (pattern & SILENCE_INVITE) - out += ",invites"; - if (pattern & SILENCE_NOTICE) - out += ",privatenotices"; - if (pattern & SILENCE_CNOTICE) - out += ",channelnotices"; - if (pattern & SILENCE_ALL) - out = ",all"; - if (pattern & SILENCE_EXCLUDE) - out += ",exclude"; - if (out.length()) - return "<" + out.substr(1) + ">"; - else - return ""; + allow_empty_last_param = false; + syntax = "[(+|-) [CcdiNnPpTtx]]"; } + CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE + { + if (parameters.empty()) + return ShowSilenceList(user); + + // If neither add nor remove are specified we default to add. + bool is_remove = parameters[0][0] == '-'; + + // If a prefix mask has been given then strip it and clean it up. + std::string mask = parameters[0]; + if (mask[0] == '-' || mask[0] == '+') + { + mask.erase(0, 1); + if (mask.empty()) + mask.assign("*"); + ModeParser::CleanMask(mask); + } + + // If the user specified a flags then use that. Otherwise, default to blocking + // all CTCPs, invites, notices, privmsgs, and invites. + uint32_t flags = SilenceEntry::SF_DEFAULT; + if (parameters.size() > 1) + { + if (!SilenceEntry::FlagsToBits(parameters[1], flags)) + { + user->WriteNumeric(ERR_SILENCE, mask, parameters[1], "You specified one or more invalid SILENCE flags"); + return CMD_FAILURE; + } + else if (flags == SilenceEntry::SF_EXEMPT) + { + // The user specified "x" with no other flags which does not make sense; add the "d" flag. + flags |= SilenceEntry::SF_DEFAULT; + } + } + + return is_remove ? RemoveSilence(user, mask, flags) : AddSilence(user, mask, flags); + } }; -class ModuleSilence : public Module +class ModuleSilence + : public Module + , public CTCTags::EventListener { - unsigned int maxsilence; - bool ExemptULine; - CommandSilence cmdsilence; - CommandSVSSilence cmdsvssilence; - public: + private: + bool exemptuline; + CommandSilence cmd; + + ModResult BuildChannelExempts(User* source, Channel* channel, SilenceEntry::SilenceFlags flag, CUList& exemptions) + { + const Channel::MemberMap& members = channel->GetUsers(); + for (Channel::MemberMap::const_iterator member = members.begin(); member != members.end(); ++member) + { + if (!CanReceiveMessage(source, member->first, flag)) + exemptions.insert(member->first); + } + return MOD_RES_PASSTHRU; + } + + bool CanReceiveMessage(User* source, User* target, SilenceEntry::SilenceFlags flag) + { + // Servers handle their own clients. + if (!IS_LOCAL(target)) + return true; + + if (exemptuline && source->server->IsULine()) + return true; + + SilenceList* list = cmd.ext.get(target); + if (!list) + return true; + for (SilenceList::iterator iter = list->begin(); iter != list->end(); ++iter) + { + if (!(iter->flags & flag)) + continue; + + if (InspIRCd::Match(source->GetFullHost(), iter->mask)) + return iter->flags & SilenceEntry::SF_EXEMPT; + } + + return true; + } + + public: ModuleSilence() - : maxsilence(32), cmdsilence(this, maxsilence), cmdsvssilence(this) + : CTCTags::EventListener(this) + , cmd(this) { } void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { ConfigTag* tag = ServerInstance->Config->ConfValue("silence"); - - maxsilence = tag->getInt("maxentries", 32); - if (!maxsilence) - maxsilence = 32; - - ExemptULine = tag->getBool("exemptuline", true); + exemptuline = tag->getBool("exemptuline", true); + cmd.ext.maxsilence = tag->getUInt("maxentries", 32, 1); } void On005Numeric(std::map& tokens) CXX11_OVERRIDE { - tokens["ESILENCE"]; - tokens["SILENCE"] = ConvToStr(maxsilence); + tokens["ESILENCE"] = "CcdiNnPpTtx"; + tokens["SILENCE"] = ConvToStr(cmd.ext.maxsilence); } - void OnBuildExemptList(MessageType message_type, Channel* chan, User* sender, char status, CUList &exempt_list, const std::string &text) + ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) CXX11_OVERRIDE { - int public_silence = (message_type == MSG_PRIVMSG ? SILENCE_CHANNEL : SILENCE_CNOTICE); + return CanReceiveMessage(source, dest, SilenceEntry::SF_INVITE) ? MOD_RES_PASSTHRU : MOD_RES_DENY; + } + + ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) CXX11_OVERRIDE + { + std::string ctcpname; + bool is_ctcp = details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION"); - const Channel::MemberMap& ulist = chan->GetUsers(); - for (Channel::MemberMap::const_iterator i = ulist.begin(); i != ulist.end(); ++i) + SilenceEntry::SilenceFlags flag = SilenceEntry::SF_NONE; + switch (target.type) { - if (IS_LOCAL(i->first)) + case MessageTarget::TYPE_CHANNEL: { - if (MatchPattern(i->first, sender, public_silence) == MOD_RES_DENY) + if (is_ctcp) + flag = SilenceEntry::SF_CTCP_CHANNEL; + else if (details.type == MSG_NOTICE) + flag = SilenceEntry::SF_NOTICE_CHANNEL; + else if (details.type == MSG_PRIVMSG) + flag = SilenceEntry::SF_PRIVMSG_CHANNEL; + + return BuildChannelExempts(user, target.Get(), flag, details.exemptions); + } + case MessageTarget::TYPE_USER: + { + if (is_ctcp) + flag = SilenceEntry::SF_CTCP_USER; + else if (details.type == MSG_NOTICE) + flag = SilenceEntry::SF_NOTICE_USER; + else if (details.type == MSG_PRIVMSG) + flag = SilenceEntry::SF_PRIVMSG_USER; + + if (!CanReceiveMessage(user, target.Get(), flag)) { - exempt_list.insert(i->first); + details.echo_original = true; + return MOD_RES_DENY; } + break; } + case MessageTarget::TYPE_SERVER: + break; } - } - ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE - { - if (target_type == TYPE_USER && IS_LOCAL(((User*)dest))) - { - return MatchPattern((User*)dest, user, ((msgtype == MSG_PRIVMSG) ? SILENCE_PRIVATE : SILENCE_NOTICE)); - } - else if (target_type == TYPE_CHANNEL) - { - Channel* chan = (Channel*)dest; - this->OnBuildExemptList(msgtype, chan, user, status, exempt_list, ""); - } return MOD_RES_PASSTHRU; } - ModResult OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout) CXX11_OVERRIDE + ModResult OnUserPreTagMessage(User* user, const MessageTarget& target, CTCTags::TagMessageDetails& details) CXX11_OVERRIDE { - return MatchPattern(dest, source, SILENCE_INVITE); - } + if (target.type == MessageTarget::TYPE_CHANNEL) + return BuildChannelExempts(user, target.Get(), SilenceEntry::SF_TAGMSG_CHANNEL, details.exemptions); - ModResult MatchPattern(User* dest, User* source, int pattern) - { - if (ExemptULine && source->server->IsULine()) - return MOD_RES_PASSTHRU; - - silencelist* sl = cmdsilence.ext.get(dest); - if (sl) + if (target.type == MessageTarget::TYPE_USER && !CanReceiveMessage(user, target.Get(), SilenceEntry::SF_TAGMSG_USER)) { - for (silencelist::const_iterator c = sl->begin(); c != sl->end(); c++) - { - if (((((c->second & pattern) > 0)) || ((c->second & SILENCE_ALL) > 0)) && (InspIRCd::Match(source->GetFullHost(), c->first))) - return (c->second & SILENCE_EXCLUDE) ? MOD_RES_PASSTHRU : MOD_RES_DENY; - } + details.echo_original = true; + return MOD_RES_DENY; } + return MOD_RES_PASSTHRU; } Version GetVersion() CXX11_OVERRIDE { - return Version("Provides support for the /SILENCE command", VF_OPTCOMMON | VF_VENDOR); + return Version("Adds the /SILENCE command which allows users to ignore other users on server-side.", VF_OPTCOMMON | VF_VENDOR); } };