src/modules/m_redirect.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2012 Shawn Smith <ShawnSmith0828@gmail.com>
   5  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   6  *   Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
   7  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   8  *   Copyright (C) 2004, 2006 Craig Edwards <craigedwards@brainbox.cc>
   9  *   Copyright (C) 2006 Oliver Lupton <oliverlupton@gmail.com>
  10  *
  11  * This file is part of InspIRCd.  InspIRCd is free software: you can
  12  * redistribute it and/or modify it under the terms of the GNU General Public
  13  * License as published by the Free Software Foundation, version 2.
  14  *
  15  * This program is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24
  25 #include "inspircd.h"
  26
  27 /** Handle channel mode +L
  28  */
  29 class Redirect : public ParamMode<Redirect, LocalStringExt>
  30 {
  31  public:
  32         Redirect(Module* Creator)
  33                 : ParamMode<Redirect, LocalStringExt>(Creator, "redirect", 'L')
  34         {
  35                 syntax = "<target>";
  36         }
  37
  38         ModeAction OnSet(User* source, Channel* channel, std::string& parameter) CXX11_OVERRIDE
  39         {
  40                 if (IS_LOCAL(source))
  41                 {
  42                         if (!ServerInstance->IsChannel(parameter))
  43                         {
  44                                 source->WriteNumeric(Numerics::NoSuchChannel(parameter));
  45                                 return MODEACTION_DENY;
  46                         }
  47                 }
  48
  49                 if (IS_LOCAL(source) && !source->IsOper())
  50                 {
  51                         Channel* c = ServerInstance->FindChan(parameter);
  52                         if (!c)
  53                         {
  54                                 source->WriteNumeric(690, InspIRCd::Format("Target channel %s must exist to be set as a redirect.", parameter.c_str()));
  55                                 return MODEACTION_DENY;
  56                         }
  57                         else if (c->GetPrefixValue(source) < OP_VALUE)
  58                         {
  59                                 source->WriteNumeric(690, InspIRCd::Format("You must be opped on %s to set it as a redirect.", parameter.c_str()));
  60                                 return MODEACTION_DENY;
  61                         }
  62                 }
  63
  64                 /*
  65                  * We used to do some checking for circular +L here, but there is no real need for this any more especially as we
  66                  * now catch +L looping in PreJoin. Remove it, since O(n) logic makes me sad, and we catch it anyway. :) -- w00t
  67                  */
  68                 ext.set(channel, parameter);
  69                 return MODEACTION_ALLOW;
  70         }
  71
  72         void SerializeParam(Channel* chan, const std::string* str, std::string& out)
  73         {
  74                 out += *str;
  75         }
  76 };
  77
  78 class ModuleRedirect : public Module
  79 {
  80         Redirect re;
  81         SimpleUserModeHandler antiredirectmode;
  82         ChanModeReference limitmode;
  83
  84  public:
  85         ModuleRedirect()
  86                 : re(this)
  87                 , antiredirectmode(this, "antiredirect", 'L')
  88                 , limitmode(this, "limit")
  89         {
  90         }
  91
  92         ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven) CXX11_OVERRIDE
  93         {
  94                 if (chan)
  95                 {
  96                         if (chan->IsModeSet(re) && chan->IsModeSet(limitmode))
  97                         {
  98                                 if (chan->GetUserCounter() >= ConvToNum<size_t>(chan->GetModeParameter(limitmode)))
  99                                 {
 100                                         const std::string& channel = *re.ext.get(chan);
 101
 102                                         /* sometimes broken ulines can make circular or chained +L, avoid this */
 103                                         Channel* destchan = ServerInstance->FindChan(channel);
 104                                         if (destchan && destchan->IsModeSet(re))
 105                                         {
 106                                                 user->WriteNumeric(470, cname, '*', "You may not join this channel. A redirect is set, but you may not be redirected as it is a circular loop.");
 107                                                 return MOD_RES_DENY;
 108                                         }
 109
 110                                         if (user->IsModeSet(antiredirectmode))
 111                                         {
 112                                                 user->WriteNumeric(470, cname, channel, "Force redirection stopped.");
 113                                                 return MOD_RES_DENY;
 114                                         }
 115                                         else
 116                                         {
 117                                                 user->WriteNumeric(470, cname, channel, "You may not join this channel, so you are automatically being transferred to the redirected channel.");
 118                                                 Channel::JoinUser(user, channel);
 119                                                 return MOD_RES_DENY;
 120                                         }
 121                                 }
 122                         }
 123                 }
 124                 return MOD_RES_PASSTHRU;
 125         }
 126
 127         Version GetVersion() CXX11_OVERRIDE
 128         {
 129                 return Version("Provides channel mode +L (limit redirection) and user mode +L (no forced redirection)", VF_VENDOR);
 130         }
 131 };
 132
 133 MODULE_INIT(ModuleRedirect)