X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_silence.cpp;h=e7271e68fc71262339f85a6990515ca4adeef618;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=089d599316dd277bb75dc6a437d271fe0905e787;hpb=553a8da754c8cd308bad2008018849714e70f9b7;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_silence.cpp b/src/modules/m_silence.cpp index 089d59931..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,376 +21,502 @@ #include "inspircd.h" +#include "modules/ctctags.h" -/* $ModDesc: Provides support for the /SILENCE command */ +enum +{ + // From ircu? + RPL_SILELIST = 271, + RPL_ENDOFSILELIST = 272, + ERR_SILELISTFULL = 511, -/* 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. - */ + // InspIRCd-specific. + ERR_SILENCE = 952 +}; -// pair of hostmask and flags -typedef std::pair silenceset; +class SilenceEntry +{ + public: + enum SilenceFlags + { + // Does nothing; for internal use only. + SF_NONE = 0, -// deque list of pairs -typedef std::deque silencelist; + // Exclude users who match this flags ("x"). + SF_EXEMPT = 1, -// 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 */ + // 2, 4, 8, 16 are reserved for future use. + // Matches a NOTICE targeted at a channel ("n"). + SF_NOTICE_CHANNEL = 32, -class CommandSVSSilence : public Command -{ - public: - CommandSVSSilence(Module* Creator) : Command(Creator,"SVSSILENCE", 2) - { - syntax = " {[+|-] }"; - TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END); /* we watch for a nick. not a UID. */ - } + // Matches a NOTICE targeted at a user ("N"). + SF_NOTICE_USER = 64, - CmdResult Handle (const std::vector& parameters, User *user) - { - /* - * 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 (!ServerInstance->ULine(user->server)) - return CMD_FAILURE; + // Matches a PRIVMSG targeted at a channel ("p"). + SF_PRIVMSG_CHANNEL = 128, - User *u = ServerInstance->FindNick(parameters[0]); - if (!u) - return CMD_FAILURE; + // Matches a PRIVMSG targeted at a user ("P"). + SF_PRIVMSG_USER = 256, - if (IS_LOCAL(u)) - { - ServerInstance->Parser->CallHandler("SILENCE", std::vector(++parameters.begin(), parameters.end()), u); - } + // Matches a TAGMSG targeted at a channel ("t"). + SF_TAGMSG_CHANNEL = 512, - return CMD_SUCCESS; - } + // Matches a TAGMSG targeted at a user ("T"). + SF_TAGMSG_USER = 1024, - RouteDescriptor GetRouting(User* user, const std::vector& parameters) - { - User* target = ServerInstance->FindNick(parameters[0]); - if (target) - return ROUTE_OPT_UCAST(target->server); - return ROUTE_LOCALONLY; - } -}; + // Matches a CTCP targeted at a channel ("c"). + SF_CTCP_CHANNEL = 2048, -class CommandSilence : public Command -{ - unsigned int& maxsilence; - public: - SimpleExtItem ext; - CommandSilence(Module* Creator, unsigned int &max) : Command(Creator, "SILENCE", 0), - maxsilence(max), ext("silence_list", Creator) - { - syntax = "{[+|-] }"; - TRANSLATE3(TR_TEXT, TR_TEXT, TR_END); - } + // Matches a CTCP targeted at a user ("C"). + SF_CTCP_USER = 4096, - CmdResult Handle (const std::vector& parameters, User *user) - { - 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++) - { - user->WriteNumeric(271, "%s %s %s %s",user->nick.c_str(), user->nick.c_str(),c->first.c_str(), DecompPattern(c->second).c_str()); - } - } - user->WriteNumeric(272, "%s :End of Silence List",user->nick.c_str()); + // Matches an invite to a channel ("i"). + SF_INVITE = 8192, - return CMD_SUCCESS; - } - else if (parameters.size() > 0) - { - // one or more parameters, add or delete entry from the list (only the first parameter is used) - std::string mask = parameters[0].substr(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()); - } + // 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 + }; - if (pattern == 0) - { - user->WriteServ("NOTICE %s :Bad SILENCE pattern",user->nick.c_str()); - return CMD_INVALID; - } + // The flags that this mask is silenced for. + uint32_t flags; - if (!mask.length()) - { - // 'SILENCE +' or 'SILENCE -', assume *!*@* - mask = "*!*@*"; - } + // The mask which is silenced (e.g. *!*@example.com). + std::string mask; - ModeParser::CleanMask(mask); + SilenceEntry(uint32_t Flags, const std::string& Mask) + : flags(Flags) + , mask(Mask) + { + } - if (action == '-') - { - // 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 %s :Removed %s %s from silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), DecompPattern(pattern).c_str()); - if (!sl->size()) - { - ext.unset(user); - } - return CMD_SUCCESS; - } - } - } - user->WriteNumeric(952, "%s %s :%s %s does not exist on your silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), DecompPattern(pattern).c_str()); - } - else if (action == '+') - { - // 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 %s :Your silence list is full",user->nick.c_str(), user->nick.c_str()); - return CMD_FAILURE; - } - 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 %s is already on your silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), DecompPattern(pattern).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 %s :Added %s %s to silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), DecompPattern(pattern).c_str()); - return CMD_SUCCESS; - } - } - return CMD_SUCCESS; + bool operator <(const SilenceEntry& other) const + { + 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; } - /* turn the nice human readable pattern into a mask */ - int CompilePattern(const char* pattern) + // Converts a flag list to a bitmask. + static bool FlagsToBits(const std::string& flags, uint32_t& out) { - int p = 0; - for (const char* n = pattern; *n; n++) + out = SF_NONE; + for (std::string::const_iterator flag = flags.begin(); flag != flags.end(); ++flag) { - switch (*n) + switch (*flag) { - case 'p': - p |= SILENCE_PRIVATE; + case 'C': + out |= SF_CTCP_USER; break; case 'c': - p |= SILENCE_CHANNEL; + out |= SF_CTCP_CHANNEL; + break; + case 'd': + out |= SF_DEFAULT; break; case 'i': - p |= SILENCE_INVITE; + out |= SF_INVITE; + break; + case 'N': + out |= SF_NOTICE_USER; break; case 'n': - p |= SILENCE_NOTICE; + out |= SF_NOTICE_CHANNEL; break; - case 't': - p |= SILENCE_CNOTICE; + case 'P': + out |= SF_PRIVMSG_USER; + break; + case 'p': + out |= SF_PRIVMSG_CHANNEL; + break; + case 'T': + out |= SF_TAGMSG_USER; break; - case 'a': - case '*': - p |= SILENCE_ALL; + case 't': + out |= SF_TAGMSG_CHANNEL; break; case 'x': - p |= SILENCE_EXCLUDE; + out |= SF_EXEMPT; break; default: - break; + out = SF_NONE; + return false; } } - return p; + return true; } - /* turn the mask into a nice human readable format */ - std::string DecompPattern (const int pattern) + // Converts a bitmask to a flag list. + static std::string BitsToFlags(uint32_t flags) { 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 ""; + 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 ModuleSilence : public Module +typedef insp::flat_set SilenceList; + +class SilenceExtItem : public SimpleExtItem { - unsigned int maxsilence; - CommandSilence cmdsilence; - CommandSVSSilence cmdsvssilence; public: + unsigned int maxsilence; - ModuleSilence() - : maxsilence(32), cmdsilence(this, maxsilence), cmdsvssilence(this) + SilenceExtItem(Module* Creator) + : SimpleExtItem("silence_list", ExtensionItem::EXT_USER, Creator) + { + } + + void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE + { + LocalUser* user = IS_LOCAL(static_cast(container)); + if (!user) + return; + + // Remove the old list and create a new one. + unset(user); + SilenceList* list = new SilenceList(); + + irc::spacesepstream ts(value); + while (!ts.StreamEnd()) + { + // 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; + } + + // Extract the mask and the flags. + std::string mask; + std::string flagstr; + if (!ts.GetToken(mask) || !ts.GetToken(flagstr)) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Malformed silence list received for %s: %s", + user->uuid.c_str(), value.c_str()); + delete list; + return; + } + + // Try to parse the flags. + uint32_t flags; + if (!SilenceEntry::FlagsToBits(flagstr, flags)) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Malformed silence flags received for %s: %s", + user->uuid.c_str(), flagstr.c_str()); + delete list; + return; + } + + // Store the silence entry. + list->insert(SilenceEntry(flags, mask)); + } + + // The value was well formed. + set(user, list); + } + + std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE { - OnRehash(NULL); - ServerInstance->AddCommand(&cmdsilence); - ServerInstance->AddCommand(&cmdsvssilence); - ServerInstance->Extensions.Register(&cmdsilence.ext); + 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(' '); - Implementation eventlist[] = { I_OnRehash, I_On005Numeric, I_OnUserPreNotice, I_OnUserPreMessage, I_OnUserPreInvite }; - ServerInstance->Modules->Attach(eventlist, this, 5); + buf.append(iter->mask); + buf.push_back(' '); + buf.append(SilenceEntry::BitsToFlags(iter->flags)); + } + return buf; } +}; - void OnRehash(User* user) +class SilenceMessage : public ClientProtocol::Message +{ + public: + SilenceMessage(const std::string& mask, const std::string& flags) + : ClientProtocol::Message("SILENCE") { - ConfigReader Conf; - maxsilence = Conf.ReadInteger("silence", "maxentries", 0, true); - if (!maxsilence) - maxsilence = 32; + PushParam(mask); + PushParam(flags); } +}; - void On005Numeric(std::string &output) +class CommandSilence : public SplitCommand +{ + private: + ClientProtocol::EventProvider msgprov; + + CmdResult AddSilence(LocalUser* user, const std::string& mask, uint32_t flags) { - // we don't really have a limit... - output = output + " ESILENCE SILENCE=" + ConvToStr(maxsilence); + 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; } - void OnBuildExemptList(MessageType message_type, Channel* chan, User* sender, char status, CUList &exempt_list, const std::string &text) + CmdResult RemoveSilence(LocalUser* user, const std::string& mask, uint32_t flags) { - int public_silence = (message_type == MSG_PRIVMSG ? SILENCE_CHANNEL : SILENCE_CNOTICE); - const UserMembList *ulist = chan->GetUsers(); + SilenceList* list = ext.get(user); + if (list) + { + for (SilenceList::iterator iter = list->begin(); iter != list->end(); ++iter) + { + if (!irc::equals(iter->mask, mask) || iter->flags != flags) + continue; + + list->erase(iter); + SilenceMessage msg("-" + mask, SilenceEntry::BitsToFlags(flags)); + user->Send(msgprov, msg); + return CMD_SUCCESS; + } + } - for (UserMembCIter i = ulist->begin(); i != ulist->end(); i++) + user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified could not be found"); + return CMD_FAILURE; + } + + CmdResult ShowSilenceList(LocalUser* user) + { + SilenceList* list = ext.get(user); + if (list) { - if (IS_LOCAL(i->first)) + for (SilenceList::const_iterator iter = list->begin(); iter != list->end(); ++iter) { - if (MatchPattern(i->first, sender, public_silence) == MOD_RES_DENY) - { - exempt_list.insert(i->first); - } + user->WriteNumeric(RPL_SILELIST, iter->mask, SilenceEntry::BitsToFlags(iter->flags)); } } + user->WriteNumeric(RPL_ENDOFSILELIST, "End of SILENCE list"); + return CMD_SUCCESS; } - ModResult PreText(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list, int silence_type) + public: + SilenceExtItem ext; + + CommandSilence(Module* Creator) + : SplitCommand(Creator, "SILENCE") + , msgprov(Creator, "SILENCE") + , ext(Creator) { - if (target_type == TYPE_USER && IS_LOCAL(((User*)dest))) + 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] == '+') { - return MatchPattern((User*)dest, user, silence_type); + mask.erase(0, 1); + if (mask.empty()) + mask.assign("*"); + ModeParser::CleanMask(mask); } - else if (target_type == TYPE_CHANNEL) + + // 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) { - Channel* chan = (Channel*)dest; - if (chan) + 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) { - this->OnBuildExemptList((silence_type == SILENCE_PRIVATE ? MSG_PRIVMSG : MSG_NOTICE), chan, user, status, exempt_list, ""); + // 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 + , public CTCTags::EventListener +{ + 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; } - ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list) + bool CanReceiveMessage(User* source, User* target, SilenceEntry::SilenceFlags flag) { - return PreText(user, dest, target_type, text, status, exempt_list, SILENCE_PRIVATE); + // 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() + : CTCTags::EventListener(this) + , cmd(this) + { + } + + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE + { + ConfigTag* tag = ServerInstance->Config->ConfValue("silence"); + exemptuline = tag->getBool("exemptuline", true); + cmd.ext.maxsilence = tag->getUInt("maxentries", 32, 1); } - ModResult OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list) + void On005Numeric(std::map& tokens) CXX11_OVERRIDE { - return PreText(user, dest, target_type, text, status, exempt_list, SILENCE_NOTICE); + tokens["ESILENCE"] = "CcdiNnPpTtx"; + tokens["SILENCE"] = ConvToStr(cmd.ext.maxsilence); } - ModResult OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout) + ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) CXX11_OVERRIDE { - return MatchPattern(dest, source, SILENCE_INVITE); + return CanReceiveMessage(source, dest, SilenceEntry::SF_INVITE) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } - ModResult MatchPattern(User* dest, User* source, int pattern) + ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) CXX11_OVERRIDE { - /* Server source */ - if (!source || !dest) - return MOD_RES_ALLOW; + std::string ctcpname; + bool is_ctcp = details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION"); - silencelist* sl = cmdsilence.ext.get(dest); - if (sl) + SilenceEntry::SilenceFlags flag = SilenceEntry::SF_NONE; + switch (target.type) { - for (silencelist::const_iterator c = sl->begin(); c != sl->end(); c++) + case MessageTarget::TYPE_CHANNEL: { - 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; + 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)) + { + details.echo_original = true; + return MOD_RES_DENY; + } + break; + } + case MessageTarget::TYPE_SERVER: + break; } + return MOD_RES_PASSTHRU; } - ~ModuleSilence() + ModResult OnUserPreTagMessage(User* user, const MessageTarget& target, CTCTags::TagMessageDetails& details) CXX11_OVERRIDE { + if (target.type == MessageTarget::TYPE_CHANNEL) + return BuildChannelExempts(user, target.Get(), SilenceEntry::SF_TAGMSG_CHANNEL, details.exemptions); + + if (target.type == MessageTarget::TYPE_USER && !CanReceiveMessage(user, target.Get(), SilenceEntry::SF_TAGMSG_USER)) + { + details.echo_original = true; + return MOD_RES_DENY; + } + + return MOD_RES_PASSTHRU; } - Version GetVersion() + 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); } };