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