From 889d521e05f2e922683d48c74eb00290e7a2f548 Mon Sep 17 00:00:00 2001 From: Sadie Powell Date: Wed, 17 Jul 2024 00:06:50 +0100 Subject: Shuffle the modules about a bit. --- modules/deaf.cpp | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 192 insertions(+) create mode 100644 modules/deaf.cpp (limited to 'modules/deaf.cpp') diff --git a/modules/deaf.cpp b/modules/deaf.cpp new file mode 100644 index 000000000..87eb180ce --- /dev/null +++ b/modules/deaf.cpp @@ -0,0 +1,192 @@ +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2019 linuxdaemon + * Copyright (C) 2019 Matt Schatz + * Copyright (C) 2013, 2017, 2019-2023 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2012 Attila Molnar + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008 Craig Edwards + * Copyright (C) 2007 Robin Burchell + * Copyright (C) 2006-2007 Dennis Friis + * + * 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 . + */ + + +#include "inspircd.h" +#include "modules/ctctags.h" + +// User mode +d - filter out channel messages and channel notices +class DeafMode final + : public SimpleUserMode +{ +public: + DeafMode(Module* Creator) + : SimpleUserMode(Creator, "deaf", 'd') + { + } + + bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override + { + if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) + return false; + + if (change.adding) + dest->WriteNotice("*** You have enabled user mode +d, deaf mode. This mode means you WILL NOT receive any messages from any channels you are in. If you did NOT mean to do this, use /mode " + dest->nick + " -d."); + + return true; + } +}; + +// User mode +D - filter out user messages and user notices +class PrivDeafMode final + : public SimpleUserMode +{ +public: + PrivDeafMode(Module* Creator) + : SimpleUserMode(Creator, "privdeaf", 'D') + { + } + + bool OnModeChange(User* source, User* dest, Channel* channel, Modes::Change& change) override + { + if (!SimpleUserMode::OnModeChange(source, dest, channel, change)) + return false; + + if (change.adding) + dest->WriteNotice("*** You have enabled user mode +D, private deaf mode. This mode means you WILL NOT receive any messages and notices from any nicks. If you did NOT mean to do this, use /mode " + dest->nick + " -D."); + + return true; + } +}; + +class ModuleDeaf final + : public Module + , public CTCTags::EventListener +{ +private: + DeafMode deafmode; + PrivDeafMode privdeafmode; + std::string deaf_bypasschars; + std::string deaf_bypasschars_service; + bool privdeafservice; + + ModResult HandleChannel(User* source, Channel* target, CUList& exemptions, bool is_bypasschar, bool is_bypasschar_service) + { + for (const auto& [member, _] : target->GetUsers()) + { + // Allow if the user doesn't have the mode set. + if (!member->IsModeSet(deafmode)) + continue; + + // Allow if the message begins with a service char and the + // user is on a services server. + if (is_bypasschar_service && member->server->IsService()) + continue; + + // Allow if the prefix begins with a normal char and the + // user is not on a services server. + if (is_bypasschar && !member->server->IsService()) + continue; + + exemptions.insert(member); + } + + return MOD_RES_PASSTHRU; + } + + ModResult HandleUser(User* source, User* target) + { + // Allow if the mode is not set. + if (!target->IsModeSet(privdeafmode)) + return MOD_RES_PASSTHRU; + + // Reject if the source is a service and privdeafservice is disabled. + if (!privdeafservice && source->server->IsService()) + return MOD_RES_DENY; + + // Reject if the source doesn't have the right priv. + if (!source->HasPrivPermission("users/ignore-privdeaf")) + return MOD_RES_DENY; + + return MOD_RES_PASSTHRU; + } + +public: + ModuleDeaf() + : Module(VF_VENDOR, "Adds user modes d (deaf) and D (privdeaf) which prevents users from receiving channel (deaf) or private (privdeaf) messages.") + , CTCTags::EventListener(this) + , deafmode(this) + , privdeafmode(this) + { + } + + void ReadConfig(ConfigStatus& status) override + { + const auto& tag = ServerInstance->Config->ConfValue("deaf"); + deaf_bypasschars = tag->getString("bypasschars"); + deaf_bypasschars_service = tag->getString("servicebypasschars"); + privdeafservice = tag->getBool("privdeafservice", true); + } + + ModResult OnUserPreTagMessage(User* user, MessageTarget& target, CTCTags::TagMessageDetails& details) override + { + switch (target.type) + { + case MessageTarget::TYPE_CHANNEL: + return HandleChannel(user, target.Get(), details.exemptions, false, false); + + case MessageTarget::TYPE_USER: + return HandleUser(user, target.Get()); + + case MessageTarget::TYPE_SERVER: + break; + } + + return MOD_RES_PASSTHRU; + } + + ModResult OnUserPreMessage(User* user, MessageTarget& target, MessageDetails& details) override + { + switch (target.type) + { + case MessageTarget::TYPE_CHANNEL: + { + // If we have no bypasschars_service in config, and this is a bypasschar (regular) + // Then it is obviously going to get through +d, no exemption list required + bool is_bypasschar = (deaf_bypasschars.find(details.text[0]) != std::string::npos); + if (deaf_bypasschars_service.empty() && is_bypasschar) + return MOD_RES_PASSTHRU; + + // If it matches both bypasschar and bypasschar_service, it will get through. + bool is_bypasschar_service = (deaf_bypasschars_service.find(details.text[0]) != std::string::npos); + if (is_bypasschar && is_bypasschar_service) + return MOD_RES_PASSTHRU; + + return HandleChannel(user, target.Get(), details.exemptions, is_bypasschar, is_bypasschar_service); + } + + case MessageTarget::TYPE_USER: + return HandleUser(user, target.Get()); + + case MessageTarget::TYPE_SERVER: + break; + } + + return MOD_RES_PASSTHRU; + } +}; + +MODULE_INIT(ModuleDeaf) -- cgit v1.3.1-10-gc9f91