X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_silence.cpp;h=e7271e68fc71262339f85a6990515ca4adeef618;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=0e9a45720b3b99bfc3f41a0be938621db388fd19;hpb=d9d99cd02dadf34bfcc220734ba0c422f0acb3e6;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_silence.cpp b/src/modules/m_silence.cpp index 0e9a45720..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,370 +21,502 @@ #include "inspircd.h" +#include "modules/ctctags.h" -/* $ModDesc: Provides support for the /SILENCE command */ - -/* 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. - */ - -// pair of hostmask and flags -typedef std::pair silenceset; - -// deque list of pairs -typedef std::deque silencelist; - -// 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 */ +enum +{ + // From ircu? + RPL_SILELIST = 271, + RPL_ENDOFSILELIST = 272, + ERR_SILELISTFULL = 511, + // InspIRCd-specific. + ERR_SILENCE = 952 +}; -class CommandSVSSilence : public Command +class SilenceEntry { public: - CommandSVSSilence(Module* Creator) : Command(Creator,"SVSSILENCE", 2) + enum SilenceFlags { - syntax = " {[+|-] }"; - TRANSLATE4(TR_NICK, TR_TEXT, TR_TEXT, TR_END); /* we watch for a nick. not a UID. */ - } + // Does nothing; for internal use only. + SF_NONE = 0, - 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; + // Exclude users who match this flags ("x"). + SF_EXEMPT = 1, - User *u = ServerInstance->FindNick(parameters[0]); - if (!u) - return CMD_FAILURE; + // 2, 4, 8, 16 are reserved for future use. - if (IS_LOCAL(u)) - { - ServerInstance->Parser->CallHandler("SILENCE", std::vector(++parameters.begin(), parameters.end()), u); - } + // Matches a NOTICE targeted at a channel ("n"). + SF_NOTICE_CHANNEL = 32, - return CMD_SUCCESS; - } + // Matches a NOTICE targeted at a user ("N"). + SF_NOTICE_USER = 64, - 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 PRIVMSG targeted at a channel ("p"). + SF_PRIVMSG_CHANNEL = 128, -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) - { - allow_empty_last_param = false; - syntax = "{[+|-] }"; - TRANSLATE3(TR_TEXT, TR_TEXT, TR_END); - } + // Matches a PRIVMSG targeted at a user ("P"). + SF_PRIVMSG_USER = 256, - 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++) - { - std::string decomppattern = DecompPattern(c->second); - user->WriteNumeric(271, "%s %s %s %s",user->nick.c_str(), user->nick.c_str(),c->first.c_str(), decomppattern.c_str()); - } - } - user->WriteNumeric(272, "%s :End of Silence List",user->nick.c_str()); + // Matches a TAGMSG targeted at a channel ("t"). + SF_TAGMSG_CHANNEL = 512, - 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()); - } + // Matches a TAGMSG targeted at a user ("T"). + SF_TAGMSG_USER = 1024, - if (pattern == 0) - { - user->WriteNotice("Bad SILENCE pattern"); - return CMD_INVALID; - } + // Matches a CTCP targeted at a channel ("c"). + SF_CTCP_CHANNEL = 2048, - if (!mask.length()) - { - // 'SILENCE +' or 'SILENCE -', assume *!*@* - mask = "*!*@*"; - } + // Matches a CTCP targeted at a user ("C"). + SF_CTCP_USER = 4096, - ModeParser::CleanMask(mask); + // Matches an invite to a channel ("i"). + SF_INVITE = 8192, - 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 %s :Removed %s %s from silence list",user->nick.c_str(), 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 %s does not exist on your silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), decomppattern.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; - } + // 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 + }; - 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 %s is already on your silence list",user->nick.c_str(), 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 %s :Added %s %s to silence list",user->nick.c_str(), user->nick.c_str(), mask.c_str(), decomppattern.c_str()); - return CMD_SUCCESS; - } - } - return CMD_SUCCESS; + // 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) + { } - /* turn the nice human readable pattern into a mask */ - int CompilePattern(const char* pattern) + bool operator <(const SilenceEntry& other) const { - int p = 0; - for (const char* n = pattern; *n; n++) + 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; + } + + // 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) { - 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 'a': - case '*': - p |= SILENCE_ALL; + case 'p': + out |= SF_PRIVMSG_CHANNEL; + break; + case 'T': + out |= SF_TAGMSG_USER; + break; + 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 init() CXX11_OVERRIDE + void FromInternal(Extensible* container, const std::string& value) CXX11_OVERRIDE { - OnRehash(NULL); - ServerInstance->Modules->AddService(cmdsilence); - ServerInstance->Modules->AddService(cmdsvssilence); - ServerInstance->Modules->AddService(cmdsilence.ext); + 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)); + } - Implementation eventlist[] = { I_OnRehash, I_On005Numeric, I_OnUserPreMessage, I_OnUserPreInvite }; - ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation)); + // The value was well formed. + set(user, list); } - void OnRehash(User* user) CXX11_OVERRIDE + std::string ToInternal(const Extensible* container, void* item) const CXX11_OVERRIDE { - maxsilence = ServerInstance->Config->ConfValue("showwhois")->getInt("maxentries", 32); - if (!maxsilence) - maxsilence = 32; + 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; } +}; - void On005Numeric(std::map& tokens) CXX11_OVERRIDE +class SilenceMessage : public ClientProtocol::Message +{ + public: + SilenceMessage(const std::string& mask, const std::string& flags) + : ClientProtocol::Message("SILENCE") { - tokens["ESILENCE"]; - tokens["SILENCE"] = ConvToStr(maxsilence); + 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; } - 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; + } + } + + user->WriteNumeric(ERR_SILENCE, mask, SilenceEntry::BitsToFlags(flags), "The SILENCE entry you specified could not be found"); + return CMD_FAILURE; + } - for (UserMembCIter i = ulist->begin(); i != ulist->end(); i++) + 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 OnUserPreMessage(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list, MessageType msgtype) CXX11_OVERRIDE + 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, ((msgtype == MSG_PRIVMSG) ? SILENCE_PRIVATE : SILENCE_NOTICE)); + 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)) { - this->OnBuildExemptList(msgtype, chan, user, status, exempt_list, ""); + 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 + , 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 OnUserPreInvite(User* source,User* dest,Channel* channel, time_t timeout) CXX11_OVERRIDE + 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() + : 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); + } + + void On005Numeric(std::map& tokens) CXX11_OVERRIDE + { + tokens["ESILENCE"] = "CcdiNnPpTtx"; + tokens["SILENCE"] = ConvToStr(cmd.ext.maxsilence); + } + + 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; + } + + 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() 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); } };