X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_silence.cpp;h=e7271e68fc71262339f85a6990515ca4adeef618;hb=262ad80560b168da596a2c2874f07c9fe263bf35;hp=9cf2912f782429765911ee3a8dc0255443d0b2b9;hpb=62814c1cfdcdf49a591ef64e2628aeaf2333a1a2;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_silence.cpp b/src/modules/m_silence.cpp index 9cf2912f7..e7271e68f 100644 --- a/src/modules/m_silence.cpp +++ b/src/modules/m_silence.cpp @@ -1,237 +1,523 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * - * - * Written by Craig Edwards, Craig McLure, and others. - * This program is free but copyrighted software; see - * the file COPYING for details. + * 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 + * 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 . */ -using namespace std; - -#include -#include -#include -#include "users.h" -#include "channels.h" -#include "modules.h" -#include "helperfuncs.h" -#include "hashcomp.h" -/* $ModDesc: Provides support for the /SILENCE command */ +#include "inspircd.h" +#include "modules/ctctags.h" +enum +{ + // From ircu? + RPL_SILELIST = 271, + RPL_ENDOFSILELIST = 272, + ERR_SILELISTFULL = 511, -// This typedef holds a silence list. Each user may or may not have a -// silencelist, if a silence list is empty for a user, he/she does not -// have one of these structures associated with their user record. -typedef std::vector silencelist; + // InspIRCd-specific. + ERR_SILENCE = 952 +}; -class cmd_silence : public command_t +class SilenceEntry { public: - cmd_silence() : command_t("SILENCE", 0, 0) + enum SilenceFlags + { + // Does nothing; for internal use only. + SF_NONE = 0, + + // Exclude users who match this flags ("x"). + SF_EXEMPT = 1, + + // 2, 4, 8, 16 are reserved for future use. + + // 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) { - this->source = "m_silence.so"; } - void Handle (char **parameters, int pcnt, userrec *user) + bool operator <(const SilenceEntry& other) const { - if (!pcnt) + 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) { - // no parameters, show the current silence list. - // Use Extensible::GetExt to fetch the silence list - silencelist* sl; - user->GetExt("silence_list", sl); - // if the user has a silence list associated with their user record, show it - if (sl) + switch (*flag) { - for (silencelist::const_iterator c = sl->begin(); c < sl->end(); c++) - { - WriteServ(user->fd,"271 %s %s %s!*@*",user->nick, user->nick,c->c_str()); - } + 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; } - WriteServ(user->fd,"272 %s :End of Silence List",user->nick); } - else if (pcnt > 0) + return true; + } + + // Converts a bitmask to a flag list. + static std::string BitsToFlags(uint32_t flags) + { + 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; + } +}; + +typedef insp::flat_set SilenceList; + +class SilenceExtItem : public SimpleExtItem +{ + public: + unsigned int maxsilence; + + 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()) { - // one or more parameters, add or delete entry from the list (only the first parameter is used) - char *nick = parameters[0]; - if (nick[0] == '-') + // Check we have space for another entry. + if (list->size() >= maxsilence) { - // removing an item from the list - nick++; - // fetch their silence list - silencelist* sl; - user->GetExt("silence_list", sl); - // does it contain any entries and does it exist? - if (sl) - { - if (sl->size()) - { - for (silencelist::iterator i = sl->begin(); i != sl->end(); i++) - { - // search through for the item - irc::string listitem = i->c_str(); - irc::string target = nick; - if (listitem == target) - { - sl->erase(i); - WriteServ(user->fd,"950 %s %s :Removed %s!*@* from silence list",user->nick, user->nick,nick); - // we have modified the vector from within a loop, we must now bail out - return; - } - } - } - if (!sl->size()) - { - // tidy up -- if a user's list is empty, theres no use having it - // hanging around in the user record. - DELETE(sl); - user->Shrink("silence_list"); - } - } + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Oversized silence list received for %s: %s", + user->uuid.c_str(), value.c_str()); + delete list; + return; } - else if (nick[0] == '+') + + // Extract the mask and the flags. + std::string mask; + std::string flagstr; + if (!ts.GetToken(mask) || !ts.GetToken(flagstr)) { - nick++; - // fetch the user's current silence list - silencelist* sl; - user->GetExt("silence_list", sl); - // what, they dont have one??? WE'RE ALL GONNA DIE! ...no, we just create an empty one. - if (!sl) - { - sl = new silencelist; - user->Extend(std::string("silence_list"), sl); - } - // add the nick to it -- silence only takes nicks for some reason even though its list shows masks - for (silencelist::iterator n = sl->begin(); n != sl->end(); n++) - { - irc::string listitem = n->c_str(); - irc::string target = nick; - if (listitem == target) - { - WriteServ(user->fd,"952 %s %s :%s is already on your silence list",user->nick, user->nick,nick); - return; - } - } - sl->push_back(std::string(nick)); - WriteServ(user->fd,"951 %s %s :Added %s!*@* to silence list",user->nick, user->nick,nick); + 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)); } - return; + + // 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 ModuleSilence : public Module +class SilenceMessage : public ClientProtocol::Message { - Server *Srv; - cmd_silence* mycommand; public: - - ModuleSilence(Server* Me) - : Module::Module(Me) + SilenceMessage(const std::string& mask, const std::string& flags) + : ClientProtocol::Message("SILENCE") { - Srv = Me; - mycommand = new cmd_silence(); - Srv->AddCommand(mycommand); + PushParam(mask); + PushParam(flags); } +}; - void Implements(char* List) +class CommandSilence : public SplitCommand +{ + private: + ClientProtocol::EventProvider msgprov; + + CmdResult AddSilence(LocalUser* user, const std::string& mask, uint32_t flags) { - List[I_OnUserQuit] = List[I_On005Numeric] = List[I_OnUserPreNotice] = List[I_OnUserPreMessage] = 1; + 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) + { + 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; } - virtual void OnUserQuit(userrec* user, const std::string &reason) + CmdResult ShowSilenceList(LocalUser* user) { - // when the user quits tidy up any silence list they might have just to keep things tidy - // and to prevent a HONKING BIG MEMORY LEAK! - silencelist* sl; - user->GetExt("silence_list", sl); - if (sl) + SilenceList* list = ext.get(user); + if (list) { - DELETE(sl); - user->Shrink("silence_list"); + for (SilenceList::const_iterator iter = list->begin(); iter != list->end(); ++iter) + { + user->WriteNumeric(RPL_SILELIST, iter->mask, SilenceEntry::BitsToFlags(iter->flags)); + } } + user->WriteNumeric(RPL_ENDOFSILELIST, "End of SILENCE list"); + return CMD_SUCCESS; } - virtual void On005Numeric(std::string &output) + public: + SilenceExtItem ext; + + CommandSilence(Module* Creator) + : SplitCommand(Creator, "SILENCE") + , msgprov(Creator, "SILENCE") + , ext(Creator) { - // we don't really have a limit... - output = output + " SILENCE=999"; + allow_empty_last_param = false; + syntax = "[(+|-) [CcdiNnPpTtx]]"; } - - virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text, char status) + + CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE { - // im not sure how unreal's silence operates but ours is sensible. It blocks notices and - // privmsgs from people on the silence list, directed privately at the user. - // channel messages are unaffected (ever tried to follow the flow of conversation in - // a channel when you've set an ignore on the two most talkative people?) - if (target_type == TYPE_USER) + 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] == '+') { - userrec* u = (userrec*)dest; - silencelist* sl; - u->GetExt("silence_list", sl); - if (sl) + 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)) { - for (silencelist::const_iterator c = sl->begin(); c != sl->end(); c++) - { - irc::string listitem = c->c_str(); - irc::string target = user->nick; - if (listitem == target) - { - return 1; - } - } + 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 0; + + return is_remove ? RemoveSilence(user, mask, flags) : AddSilence(user, mask, flags); } +}; - virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text, char status) +class ModuleSilence + : public Module + , public CTCTags::EventListener +{ + private: + bool exemptuline; + CommandSilence cmd; + + ModResult BuildChannelExempts(User* source, Channel* channel, SilenceEntry::SilenceFlags flag, CUList& exemptions) { - return OnUserPreNotice(user,dest,target_type,text,status); + 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; } - virtual ~ModuleSilence() + 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; } - - virtual Version GetVersion() + + public: + ModuleSilence() + : CTCTags::EventListener(this) + , cmd(this) { - return Version(1,0,0,1,VF_VENDOR); } -}; + 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); + } -class ModuleSilenceFactory : public ModuleFactory -{ - public: - ModuleSilenceFactory() + void On005Numeric(std::map& tokens) CXX11_OVERRIDE { + tokens["ESILENCE"] = "CcdiNnPpTtx"; + tokens["SILENCE"] = ConvToStr(cmd.ext.maxsilence); } - - ~ModuleSilenceFactory() + + ModResult OnUserPreInvite(User* source, User* dest, Channel* channel, time_t timeout) CXX11_OVERRIDE { + return CanReceiveMessage(source, dest, SilenceEntry::SF_INVITE) ? MOD_RES_PASSTHRU : MOD_RES_DENY; } - - virtual Module * CreateModule(Server* Me) + + ModResult OnUserPreMessage(User* user, const MessageTarget& target, MessageDetails& details) CXX11_OVERRIDE { - return new ModuleSilence(Me); + std::string ctcpname; + bool is_ctcp = details.IsCTCP(ctcpname) && !irc::equals(ctcpname, "ACTION"); + + SilenceEntry::SilenceFlags flag = SilenceEntry::SF_NONE; + switch (target.type) + { + case MessageTarget::TYPE_CHANNEL: + { + 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); -extern "C" void * init_module( void ) -{ - return new ModuleSilenceFactory; -} + 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("Adds the /SILENCE command which allows users to ignore other users on server-side.", VF_OPTCOMMON | VF_VENDOR); + } +}; +MODULE_INIT(ModuleSilence)