src/modules/m_joinflood.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   6  *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
   7  *   Copyright (C) 2006-2007 Craig Edwards <craigedwards@brainbox.cc>
   8  *   Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
   9  *
  10  * This file is part of InspIRCd.  InspIRCd is free software: you can
  11  * redistribute it and/or modify it under the terms of the GNU General Public
  12  * License as published by the Free Software Foundation, version 2.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23
  24 #include "inspircd.h"
  25
  26 enum
  27 {
  28         // From RFC 2182.
  29         ERR_UNAVAILRESOURCE = 437
  30 };
  31
  32 // The number of seconds the channel will be closed for.
  33 static unsigned int duration;
  34
  35 /** Holds settings and state associated with channel mode +j
  36  */
  37 class joinfloodsettings
  38 {
  39  public:
  40         unsigned int secs;
  41         unsigned int joins;
  42         time_t reset;
  43         time_t unlocktime;
  44         unsigned int counter;
  45
  46         joinfloodsettings(unsigned int b, unsigned int c)
  47                 : secs(b), joins(c), unlocktime(0), counter(0)
  48         {
  49                 reset = ServerInstance->Time() + secs;
  50         }
  51
  52         void addjoin()
  53         {
  54                 if (ServerInstance->Time() > reset)
  55                 {
  56                         counter = 1;
  57                         reset = ServerInstance->Time() + secs;
  58                 }
  59                 else
  60                         counter++;
  61         }
  62
  63         bool shouldlock()
  64         {
  65                 return (counter >= this->joins);
  66         }
  67
  68         void clear()
  69         {
  70                 counter = 0;
  71         }
  72
  73         bool islocked()
  74         {
  75                 if (ServerInstance->Time() > unlocktime)
  76                         unlocktime = 0;
  77
  78                 return (unlocktime != 0);
  79         }
  80
  81         void lock()
  82         {
  83                 unlocktime = ServerInstance->Time() + duration;
  84         }
  85
  86         bool operator==(const joinfloodsettings& other) const
  87         {
  88                 return ((this->secs == other.secs) && (this->joins == other.joins));
  89         }
  90 };
  91
  92 /** Handles channel mode +j
  93  */
  94 class JoinFlood : public ParamMode<JoinFlood, SimpleExtItem<joinfloodsettings> >
  95 {
  96  public:
  97         JoinFlood(Module* Creator)
  98                 : ParamMode<JoinFlood, SimpleExtItem<joinfloodsettings> >(Creator, "joinflood", 'j')
  99         {
 100         }
 101
 102         ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
 103         {
 104                 std::string::size_type colon = parameter.find(':');
 105                 if ((colon == std::string::npos) || (parameter.find('-') != std::string::npos))
 106                 {
 107                         source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter));
 108                         return MODEACTION_DENY;
 109                 }
 110
 111                 /* Set up the flood parameters for this channel */
 112                 unsigned int njoins = ConvToInt(parameter.substr(0, colon));
 113                 unsigned int nsecs = ConvToInt(parameter.substr(colon+1));
 114                 if ((njoins<1) || (nsecs<1))
 115                 {
 116                         source->WriteNumeric(Numerics::InvalidModeParameter(channel, this, parameter));
 117                         return MODEACTION_DENY;
 118                 }
 119
 120                 ext.set(channel, new joinfloodsettings(nsecs, njoins));
 121                 return MODEACTION_ALLOW;
 122         }
 123
 124         void SerializeParam(Channel* chan, const joinfloodsettings* jfs, std::string& out)
 125         {
 126                 out.append(ConvToStr(jfs->joins)).push_back(':');
 127                 out.append(ConvToStr(jfs->secs));
 128         }
 129 };
 130
 131 class ModuleJoinFlood : public Module
 132 {
 133         JoinFlood jf;
 134
 135  public:
 136         ModuleJoinFlood()
 137                 : jf(this)
 138         {
 139         }
 140
 141         void ReadConfig(ConfigStatus&) CXX11_OVERRIDE
 142         {
 143                 ConfigTag* tag = ServerInstance->Config->ConfValue("joinflood");
 144                 duration = tag->getDuration("duration", 60, 10, 600);
 145         }
 146
 147         ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven) CXX11_OVERRIDE
 148         {
 149                 if (chan)
 150                 {
 151                         joinfloodsettings *f = jf.ext.get(chan);
 152                         if (f && f->islocked())
 153                         {
 154                                 user->WriteNumeric(ERR_UNAVAILRESOURCE, chan->name, "This channel is temporarily unavailable (+j). Please try again later.");
 155                                 return MOD_RES_DENY;
 156                         }
 157                 }
 158                 return MOD_RES_PASSTHRU;
 159         }
 160
 161         void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts) CXX11_OVERRIDE
 162         {
 163                 /* We arent interested in JOIN events caused by a network burst */
 164                 if (sync)
 165                         return;
 166
 167                 joinfloodsettings *f = jf.ext.get(memb->chan);
 168
 169                 /* But all others are OK */
 170                 if ((f) && (!f->islocked()))
 171                 {
 172                         f->addjoin();
 173                         if (f->shouldlock())
 174                         {
 175                                 f->clear();
 176                                 f->lock();
 177                                 memb->chan->WriteNotice(InspIRCd::Format("This channel has been closed to new users for %u seconds because there have been more than %d joins in %d seconds.", duration, f->joins, f->secs));
 178                         }
 179                 }
 180         }
 181
 182         Version GetVersion() CXX11_OVERRIDE
 183         {
 184                 return Version("Provides channel mode +j (join flood protection)", VF_VENDOR);
 185         }
 186 };
 187
 188 MODULE_INIT(ModuleJoinFlood)