X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_delaymsg.cpp;h=978ab55d2191c94b31bb74862bf454f4f01ce72d;hb=a5d110282a864fd2e91b51ce360a977cd0643657;hp=b732e4523f2b9ad9fa7743a5b0ce90a79417a08d;hpb=8f8e244f4f350a53a2a84296a66468b7e5ac4a2b;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_delaymsg.cpp b/src/modules/m_delaymsg.cpp index b732e4523..978ab55d2 100644 --- a/src/modules/m_delaymsg.cpp +++ b/src/modules/m_delaymsg.cpp @@ -1,46 +1,42 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2009 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2009 Daniel De Graaf * - * This program is free but copyrighted software; see - * the file COPYING for details. + * 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 + +/* $ModDesc: Provides channelmode +d , to deny messages to a channel until seconds. */ class DelayMsgMode : public ModeHandler { - private: - CUList empty; - Module* Creator; public: - DelayMsgMode(InspIRCd* Instance, Module* Parent) : ModeHandler(Instance, 'd', 1, 0, false, MODETYPE_CHANNEL, false, 0, '@'), Creator(Parent) {}; - - ModePair ModeSet(User*, User*, Channel* channel, const std::string ¶meter) + LocalIntExt jointime; + DelayMsgMode(Module* Parent) : ModeHandler(Parent, "delaymsg", 'd', PARAM_SETONLY, MODETYPE_CHANNEL) + , jointime("delaymsg", Parent) { - std::string climit = channel->GetModeParameter('d'); - if (!climit.empty()) - { - return std::make_pair(true, climit); - } - else - { - return std::make_pair(false, parameter); - } + levelrequired = OP_VALUE; } - bool CheckTimeStamp(std::string &their_param, const std::string &our_param, Channel*) + bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel*) { return (atoi(their_param.c_str()) < atoi(our_param.c_str())); } - ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool); + ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding); }; class ModuleDelayMsg : public Module @@ -48,28 +44,32 @@ class ModuleDelayMsg : public Module private: DelayMsgMode djm; public: - ModuleDelayMsg(InspIRCd* Me) : Module(Me), djm(Me, this) + ModuleDelayMsg() : djm(this) { - if (!ServerInstance->Modes->AddMode(&djm)) - throw ModuleException("Could not add new modes!"); - Implementation eventlist[] = { I_OnUserJoin, I_OnUserPart, I_OnUserKick, I_OnCleanup, I_OnUserPreMessage}; - ServerInstance->Modules->Attach(eventlist, this, 5); } - virtual ~ModuleDelayMsg(); - virtual Version GetVersion(); - void OnUserJoin(User* user, Channel* channel, bool sync, bool &silent, bool created); - void OnUserPart(User* user, Channel* channel, std::string &partmessage, bool &silent); - void OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent); - void OnCleanup(int target_type, void* item); - int OnUserPreMessage(User* user, void* dest, int target_type, std::string &text, char status, CUList &exempt_list); -}; -/* $ModDesc: Allows for delay-join channels (+D) where users dont appear to join until they speak */ + void init() + { + ServerInstance->Modules->AddService(djm); + ServerInstance->Modules->AddService(djm.jointime); + Implementation eventlist[] = { I_OnUserJoin, I_OnUserPreMessage, I_OnRehash }; + ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation)); + OnRehash(NULL); + } + Version GetVersion(); + void OnUserJoin(Membership* memb, bool sync, bool created, CUList&); + ModResult OnUserPreMessage(User* user, void* dest, int target_type, std::string &text, char status, CUList &exempt_list); + ModResult OnUserPreNotice(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list); + void OnRehash(User* user); +}; -ModeAction DelayMsgMode::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool) +ModeAction DelayMsgMode::OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding) { if (adding) { + if ((channel->IsModeSet('d')) && (channel->GetModeParameter('d') == parameter)) + return MODEACTION_DENY; + /* Setting a new limit, sanity check */ long limit = atoi(parameter.c_str()); @@ -81,91 +81,84 @@ ModeAction DelayMsgMode::OnModeChange(User* source, User* dest, Channel* channel } else { + if (!channel->IsModeSet('d')) + return MODEACTION_DENY; + /* * Clean up metadata */ - CUList* names = channel->GetUsers(); - for (CUListIter n = names->begin(); n != names->end(); ++n) - n->first->Shrink("delaymsg_" + channel->name); + const UserMembList* names = channel->GetUsers(); + for (UserMembCIter n = names->begin(); n != names->end(); ++n) + jointime.set(n->second, 0); } channel->SetModeParam('d', adding ? parameter : ""); return MODEACTION_ALLOW; } -ModuleDelayMsg::~ModuleDelayMsg() -{ - ServerInstance->Modes->DelMode(&djm); -} - Version ModuleDelayMsg::GetVersion() { - return Version("$Id$", VF_COMMON | VF_VENDOR, API_VERSION); + return Version("Provides channelmode +d , to deny messages to a channel until seconds.", VF_VENDOR); } -void ModuleDelayMsg::OnUserJoin(User* user, Channel* channel, bool sync, bool &silent, bool created) +void ModuleDelayMsg::OnUserJoin(Membership* memb, bool sync, bool created, CUList&) { - if (channel->IsModeSet('d')) - user->Extend("delaymsg_"+channel->name, reinterpret_cast(ServerInstance->Time())); -} - -void ModuleDelayMsg::OnUserPart(User* user, Channel* channel, std::string &partmessage, bool &silent) -{ - user->Shrink("delaymsg_"+channel->name); -} - -void ModuleDelayMsg::OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent) -{ - user->Shrink("delaymsg_"+chan->name); -} - -void ModuleDelayMsg::OnCleanup(int target_type, void* item) -{ - if (target_type == TYPE_USER) + if ((IS_LOCAL(memb->user)) && (memb->chan->IsModeSet('d'))) { - User* user = (User*)item; - for (UCListIter f = user->chans.begin(); f != user->chans.end(); f++) - { - Channel* chan = f->first; - user->Shrink("delaymsg_"+chan->name); - } + djm.jointime.set(memb, ServerInstance->Time()); } } -int ModuleDelayMsg::OnUserPreMessage(User* user, void* dest, int target_type, std::string &text, char status, CUList &exempt_list) +ModResult ModuleDelayMsg::OnUserPreMessage(User* user, void* dest, int target_type, std::string &text, char status, CUList &exempt_list) { /* Server origin */ - if (!user) - return false; + if ((!user) || (!IS_LOCAL(user))) + return MOD_RES_PASSTHRU; if (target_type != TYPE_CHANNEL) - return false; + return MOD_RES_PASSTHRU; Channel* channel = (Channel*) dest; + Membership* memb = channel->GetUser(user); - void* jointime_as_ptr; + if (!memb) + return MOD_RES_PASSTHRU; - if (!user->GetExt("delaymsg_"+channel->name, jointime_as_ptr)) - return false; + time_t ts = djm.jointime.get(memb); - time_t jointime = reinterpret_cast(jointime_as_ptr); + if (ts == 0) + return MOD_RES_PASSTHRU; std::string len = channel->GetModeParameter('d'); - if (jointime + atoi(len.c_str()) > ServerInstance->Time()) + if (ts + atoi(len.c_str()) > ServerInstance->Time()) { - if (channel->GetStatus(user) < STATUS_VOICE) + if (channel->GetPrefixValue(user) < VOICE_VALUE) { user->WriteNumeric(404, "%s %s :You must wait %s seconds after joining to send to channel (+d)", user->nick.c_str(), channel->name.c_str(), len.c_str()); - return true; + return MOD_RES_DENY; } } else { /* Timer has expired, we can stop checking now */ - user->Shrink("delaymsg_"+channel->name); + djm.jointime.set(memb, 0); } - return false; + return MOD_RES_PASSTHRU; +} + +ModResult ModuleDelayMsg::OnUserPreNotice(User* user, void* dest, int target_type, std::string& text, char status, CUList& exempt_list) +{ + return OnUserPreMessage(user, dest, target_type, text, status, exempt_list); +} + +void ModuleDelayMsg::OnRehash(User* user) +{ + ConfigTag* tag = ServerInstance->Config->ConfValue("delaymsg"); + if (tag->getBool("allownotice", true)) + ServerInstance->Modules->Detach(I_OnUserPreNotice, this); + else + ServerInstance->Modules->Attach(I_OnUserPreNotice, this); } MODULE_INIT(ModuleDelayMsg)