src/modules/m_kicknorejoin.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2008 Pippijn van Steenhoven <pip88nl@gmail.com>
   6  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   7  *   Copyright (C) 2006-2007 Robin Burchell <robin+git@viroteck.net>
   8  *   Copyright (C) 2006 John Brooks <john.brooks@dereferenced.net>
   9  *   Copyright (C) 2006 Craig Edwards <craigedwards@brainbox.cc>
  10  *   Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
  11  *
  12  * This file is part of InspIRCd.  InspIRCd is free software: you can
  13  * redistribute it and/or modify it under the terms of the GNU General Public
  14  * License as published by the Free Software Foundation, version 2.
  15  *
  16  * This program is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  18  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  19  * details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25
  26 #include "inspircd.h"
  27
  28 /* $ModDesc: Provides channel mode +J (delay rejoin after kick) */
  29
  30 typedef std::map<User*, time_t> delaylist;
  31
  32 /** Handles channel mode +J
  33  */
  34 class KickRejoin : public ParamChannelModeHandler
  35 {
  36  public:
  37         SimpleExtItem<delaylist> ext;
  38         KickRejoin(Module* Creator) : ParamChannelModeHandler(Creator, "kicknorejoin", 'J'), ext("norejoinusers", Creator) { }
  39
  40         bool ParamValidate(std::string& parameter)
  41         {
  42                 int v = atoi(parameter.c_str());
  43                 if (v <= 0)
  44                         return false;
  45                 parameter = ConvToStr(v);
  46                 return true;
  47         }
  48
  49         ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding)
  50         {
  51                 ModeAction rv = ParamChannelModeHandler::OnModeChange(source, dest, channel, parameter, adding);
  52                 if (rv == MODEACTION_ALLOW && !adding)
  53                         ext.unset(channel);
  54                 return rv;
  55         }
  56 };
  57
  58 class ModuleKickNoRejoin : public Module
  59 {
  60         KickRejoin kr;
  61
  62 public:
  63         ModuleKickNoRejoin()
  64                 : kr(this)
  65         {
  66         }
  67
  68         void init()
  69         {
  70                 ServerInstance->Modules->AddService(kr);
  71                 ServerInstance->Modules->AddService(kr.ext);
  72                 Implementation eventlist[] = { I_OnUserPreJoin, I_OnUserKick };
  73                 ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
  74         }
  75
  76         ModResult OnUserPreJoin(User* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven)
  77         {
  78                 if (chan)
  79                 {
  80                         delaylist* dl = kr.ext.get(chan);
  81                         if (dl)
  82                         {
  83                                 std::vector<User*> itemstoremove;
  84
  85                                 for (delaylist::iterator iter = dl->begin(); iter != dl->end(); iter++)
  86                                 {
  87                                         if (iter->second > ServerInstance->Time())
  88                                         {
  89                                                 if (iter->first == user)
  90                                                 {
  91                                                         std::string modeparam = chan->GetModeParameter(&kr);
  92                                                         user->WriteNumeric(ERR_DELAYREJOIN, "%s %s :You must wait %s seconds after being kicked to rejoin (+J)",
  93                                                                 user->nick.c_str(), chan->name.c_str(), modeparam.c_str());
  94                                                         return MOD_RES_DENY;
  95                                                 }
  96                                         }
  97                                         else
  98                                         {
  99                                                 // Expired record, remove.
 100                                                 itemstoremove.push_back(iter->first);
 101                                         }
 102                                 }
 103
 104                                 for (unsigned int i = 0; i < itemstoremove.size(); i++)
 105                                         dl->erase(itemstoremove[i]);
 106
 107                                 if (!dl->size())
 108                                         kr.ext.unset(chan);
 109                         }
 110                 }
 111                 return MOD_RES_PASSTHRU;
 112         }
 113
 114         void OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& excepts)
 115         {
 116                 if (memb->chan->IsModeSet(&kr) && (source != memb->user))
 117                 {
 118                         delaylist* dl = kr.ext.get(memb->chan);
 119                         if (!dl)
 120                         {
 121                                 dl = new delaylist;
 122                                 kr.ext.set(memb->chan, dl);
 123                         }
 124                         (*dl)[memb->user] = ServerInstance->Time() + ConvToInt(memb->chan->GetModeParameter(&kr));
 125                 }
 126         }
 127
 128         Version GetVersion()
 129         {
 130                 return Version("Channel mode to delay rejoin after kick", VF_VENDOR);
 131         }
 132 };
 133
 134 MODULE_INIT(ModuleKickNoRejoin)