src/modules/m_alias.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 using namespace std;
  18
  19 #include "users.h"
  20 #include "channels.h"
  21 #include "modules.h"
  22 #include "inspircd.h"
  23 #include <vector>
  24
  25 /* $ModDesc: Provides aliases of commands. */
  26
  27 /** An alias definition
  28  */
  29 class Alias : public classbase
  30 {
  31  public:
  32         /** The text of the alias command */
  33         irc::string text;
  34         /** Text to replace with */
  35         std::string replace_with;
  36         /** Nickname required to perform alias */
  37         std::string requires;
  38         /** Alias requires ulined server */
  39         bool uline;
  40 };
  41
  42 class ModuleAlias : public Module
  43 {
  44  private:
  45         ConfigReader *MyConf;
  46         std::vector<Alias> Aliases;
  47
  48         virtual void ReadAliases()
  49         {
  50                 Aliases.clear();
  51
  52                 for (int i = 0; i < MyConf->Enumerate("alias"); i++)
  53                 {
  54                         Alias a;
  55                         std::string txt;
  56                         txt = MyConf->ReadValue("alias", "text", i);
  57                         a.text = txt.c_str();
  58                         a.replace_with = MyConf->ReadValue("alias", "replace", i);
  59                         a.requires = MyConf->ReadValue("alias", "requires", i);
  60
  61                         a.uline =       ((MyConf->ReadValue("alias", "uline", i) == "yes") ||
  62                                         (MyConf->ReadValue("alias", "uline", i) == "1") ||
  63                                                 (MyConf->ReadValue("alias", "uline", i) == "true"));
  64
  65                         Aliases.push_back(a);
  66                 }
  67
  68         }
  69
  70  public:
  71
  72         ModuleAlias(InspIRCd* Me)
  73                 : Module::Module(Me)
  74         {
  75
  76                 MyConf = new ConfigReader(ServerInstance);
  77                 ReadAliases();
  78         }
  79
  80         void Implements(char* List)
  81         {
  82                 List[I_OnPreCommand] = List[I_OnRehash] = 1;
  83         }
  84
  85         virtual ~ModuleAlias()
  86         {
  87                 DELETE(MyConf);
  88         }
  89
  90         virtual Version GetVersion()
  91         {
  92                 return Version(1,0,0,1,VF_VENDOR);
  93         }
  94
  95         virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated)
  96         {
  97                 userrec *u = NULL;
  98                 irc::string c = command.c_str();
  99                 /* If the command is valid, we dont want to know,
 100                  * and if theyre not registered yet, we dont want
 101                  * to know either
 102                  */
 103                 if ((validated) || (user->registered != REG_ALL))
 104                         return 0;
 105
 106                 for (unsigned int i = 0; i < Aliases.size(); i++)
 107                 {
 108                         if (Aliases[i].text == c)
 109                         {
 110                                 if (Aliases[i].requires != "")
 111                                 {
 112                                         u = ServerInstance->FindNick(Aliases[i].requires);
 113                                         if (!u)
 114                                         {
 115                                                 user->WriteServ("401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
 116                                                 return 1;
 117                                         }
 118                                 }
 119                                 if ((u != NULL) && (Aliases[i].requires != "") && (Aliases[i].uline))
 120                                 {
 121                                         if (!ServerInstance->ULine(u->server))
 122                                         {
 123                                                 ServerInstance->WriteOpers("*** NOTICE -- Service "+Aliases[i].requires+" required by alias "+std::string(Aliases[i].text.c_str())+" is not on a u-lined server, possibly underhanded antics detected!");
 124                                                 user->WriteServ("401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is an imposter! Please inform an IRC operator as soon as possible.");
 125                                                 return 1;
 126                                         }
 127                                 }
 128                                         std::string n = "";
 129                                 for (int j = 0; j < pcnt; j++)
 130                                 {
 131                                         if (j)
 132                                                 n = n + " ";
 133                                         n = n + parameters[j];
 134                                 }
 135                                 /* Final param now in n as one string */
 136                                 std::stringstream stuff(Aliases[i].replace_with);
 137                                         std::string cmd = "";
 138                                 std::string target = "";
 139                                 stuff >> cmd;
 140                                 stuff >> target;
 141                                         const char* para[2];
 142                                 para[0] = target.c_str();
 143                                 para[1] = n.c_str();
 144                                         ServerInstance->CallCommandHandler(cmd,para,2,user);
 145                                 return 1;
 146                         }
 147                 }
 148                 return 0;
 149         }
 150
 151         virtual void OnRehash(const std::string &parameter)
 152         {
 153                 DELETE(MyConf);
 154                 MyConf = new ConfigReader(ServerInstance);
 155
 156                 ReadAliases();
 157         }
 158 };
 159
 160
 161 class ModuleAliasFactory : public ModuleFactory
 162 {
 163  public:
 164         ModuleAliasFactory()
 165         {
 166         }
 167
 168         ~ModuleAliasFactory()
 169         {
 170         }
 171
 172                 virtual Module * CreateModule(InspIRCd* Me)
 173         {
 174                 return new ModuleAlias(Me);
 175         }
 176 };
 177
 178
 179 extern "C" void * init_module( void )
 180 {
 181         return new ModuleAliasFactory;
 182 }
 183