src/modules/m_alias.cpp

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