src/modules/m_override.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 #include "users.h"
  18 #include "channels.h"
  19 #include "modules.h"
  20 #include "helperfuncs.h"
  21 #include "inspircd.h"
  22
  23 /* $ModDesc: Provides support for unreal-style oper-override */
  24
  25 typedef std::map<std::string,std::string> override_t;
  26
  27 class ModuleOverride : public Module
  28 {
  29         Server *Srv;
  30         override_t overrides;
  31         bool NoisyOverride;
  32  public:
  33
  34         ModuleOverride(Server* Me)
  35                 : Module::Module(Me)
  36         {
  37
  38                 // here we initialise our module. Use new to create new instances of the required
  39                 // classes.
  40
  41                 Srv = Me;
  42
  43                 // read our config options (main config file)
  44                 OnRehash("");
  45         }
  46
  47         virtual void OnRehash(const std::string &parameter)
  48         {
  49                 // on a rehash we delete our classes for good measure and create them again.
  50                 ConfigReader* Conf = new ConfigReader;
  51
  52                 // re-read our config options on a rehash
  53                 NoisyOverride = Conf->ReadFlag("override","noisy",0);
  54                 overrides.clear();
  55                 for (int j =0; j < Conf->Enumerate("type"); j++)
  56                 {
  57                         std::string typen = Conf->ReadValue("type","name",j);
  58                         std::string tokenlist = Conf->ReadValue("type","override",j);
  59                         overrides[typen] = tokenlist;
  60                 }
  61
  62                 DELETE(Conf);
  63         }
  64
  65         void Implements(char* List)
  66         {
  67                 List[I_OnRehash] = List[I_OnAccessCheck] = List[I_On005Numeric] = List[I_OnUserPreJoin] = List[I_OnUserPreKick] = 1;
  68         }
  69
  70         virtual void On005Numeric(std::string &output)
  71         {
  72                 output.append(" OVERRIDE");
  73         }
  74
  75         virtual bool CanOverride(userrec* source, char* token)
  76         {
  77                 // checks to see if the oper's type has <type:override>
  78                 override_t::iterator j = overrides.find(source->oper);
  79
  80                 if (j != overrides.end())
  81                 {
  82                         // its defined, return its value as a boolean for if the token is set
  83                         return (j->second.find(token, 0) != std::string::npos);
  84                 }
  85
  86                 // its not defined at all, count as false
  87                 return false;
  88         }
  89
  90         virtual int OnUserPreKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason)
  91         {
  92                 if ((*source->oper) && (CanOverride(source,"KICK")))
  93                 {
  94                         if (((Srv->ChanMode(source,chan) == "%") && (Srv->ChanMode(user,chan) == "@")) || (Srv->ChanMode(source,chan) == ""))
  95                         {
  96                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Kicked "+std::string(user->nick)+" on "+std::string(chan->name)+" ("+reason+")");
  97                         }
  98                         /* Returning -1 explicitly allows the kick */
  99                         return -1;
 100                 }
 101                 return 0;
 102         }
 103
 104         virtual int OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type)
 105         {
 106                 if (*source->oper)
 107                 {
 108                         if ((Srv) && (source) && (channel))
 109                         {
 110                                 // Fix by brain - allow the change if they arent on channel - rely on boolean short-circuit
 111                                 // to not check the other items in the statement if they arent on the channel
 112                                 std::string mode = Srv->ChanMode(source,channel);
 113                                 if ((!channel->HasUser(source)) || ((mode != "%") && (mode != "@")))
 114                                 {
 115                                         switch (access_type)
 116                                         {
 117                                                 case AC_DEOP:
 118                                                         if (CanOverride(source,"MODEDEOP"))
 119                                                         {
 120                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Deopped "+std::string(dest->nick)+" on "+std::string(channel->name));
 121                                                                 return ACR_ALLOW;
 122                                                         }
 123                                                         else
 124                                                         {
 125                                                                 return ACR_DEFAULT;
 126                                                         }
 127
 128                                                 case AC_OP:
 129                                                         if (CanOverride(source,"MODEOP"))
 130                                                         {
 131                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Opped "+std::string(dest->nick)+" on "+std::string(channel->name));
 132                                                                 return ACR_ALLOW;
 133                                                         }
 134                                                         else
 135                                                         {
 136                                                                 return ACR_DEFAULT;
 137                                                         }
 138
 139                                                 case AC_VOICE:
 140                                                         if (CanOverride(source,"MODEVOICE"))
 141                                                         {
 142                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Voiced "+std::string(dest->nick)+" on "+std::string(channel->name));
 143                                                                 return ACR_ALLOW;
 144                                                         }
 145                                                         else
 146                                                         {
 147                                                                 return ACR_DEFAULT;
 148                                                         }
 149
 150                                                 case AC_DEVOICE:
 151                                                         if (CanOverride(source,"MODEDEVOICE"))
 152                                                         {
 153                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Devoiced "+std::string(dest->nick)+" on "+std::string(channel->name));
 154                                                                 return ACR_ALLOW;
 155                                                         }
 156                                                         else
 157                                                         {
 158                                                                 return ACR_DEFAULT;
 159                                                         }
 160
 161                                                 case AC_HALFOP:
 162                                                         if (CanOverride(source,"MODEHALFOP"))
 163                                                         {
 164                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Halfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
 165                                                                 return ACR_ALLOW;
 166                                                         }
 167                                                         else
 168                                                         {
 169                                                                 return ACR_DEFAULT;
 170                                                         }
 171
 172                                                 case AC_DEHALFOP:
 173                                                         if (CanOverride(source,"MODEDEHALFOP"))
 174                                                         {
 175                                                                 Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Dehalfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
 176                                                                 return ACR_ALLOW;
 177                                                         }
 178                                                         else
 179                                                         {
 180                                                                 return ACR_DEFAULT;
 181                                                         }
 182                                         }
 183                                 }
 184                         }
 185
 186                         if (CanOverride(source,"OTHERMODE"))
 187                         {
 188                                 return ACR_ALLOW;
 189                         }
 190                         else
 191                         {
 192                                 return ACR_DEFAULT;
 193                         }
 194                 }
 195
 196                 return ACR_DEFAULT;
 197         }
 198
 199         virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname)
 200         {
 201                 if (*user->oper)
 202                 {
 203                         if (chan)
 204                         {
 205                                 if ((chan->modes[CM_INVITEONLY]) && (CanOverride(user,"INVITE")))
 206                                 {
 207                                         if (NoisyOverride)
 208                                         {
 209                                                 irc::string x = chan->name;
 210                                                 if (!user->IsInvited(x))
 211                                                 {
 212                                                         /* XXX - Ugly cast for a parameter that isn't used? :< - Om */
 213                                                         chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s invited himself into the channel", cname, user->nick);
 214                                                 }
 215                                         }
 216                                         Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +i on "+std::string(cname));
 217                                         return -1;
 218                                 }
 219
 220                                 if ((chan->key[0]) && (CanOverride(user,"KEY")))
 221                                 {
 222                                         if (NoisyOverride)
 223                                                 chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s bypassed the channel key", cname, user->nick);
 224                                         Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +k on "+std::string(cname));
 225                                         return -1;
 226                                 }
 227
 228                                 if ((chan->limit > 0) && (chan->GetUserCounter() >=  chan->limit) && (CanOverride(user,"LIMIT")))
 229                                 {
 230                                         if (NoisyOverride)
 231                                                 chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s passed through your channel limit", cname, user->nick);
 232                                         Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +l on "+std::string(cname));
 233                                         return -1;
 234                                 }
 235
 236                                 if (CanOverride(user,"BANWALK"))
 237                                 {
 238                                         // other join
 239                                         return -1;
 240                                 }
 241                         }
 242                 }
 243                 return 0;
 244         }
 245
 246         virtual ~ModuleOverride()
 247         {
 248         }
 249
 250         virtual Version GetVersion()
 251         {
 252                 return Version(1,0,0,1,VF_VENDOR);
 253         }
 254 };
 255
 256
 257 class ModuleOverrideFactory : public ModuleFactory
 258 {
 259  public:
 260         ModuleOverrideFactory()
 261         {
 262         }
 263
 264         ~ModuleOverrideFactory()
 265         {
 266         }
 267
 268         virtual Module * CreateModule(Server* Me)
 269         {
 270                 return new ModuleOverride(Me);
 271         }
 272
 273 };
 274
 275
 276 extern "C" void * init_module( void )
 277 {
 278         return new ModuleOverrideFactory;
 279 }