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                 /* XXX - small issue, why is this marked public when it's not (really) intended for external use
  44                  * Fixed 30/11/05 by Brain as suggestion by w00t */
  45                 virtual void ReadAliases()
  46                 {
  47                         Aliases.clear();
  48
  49                         for (int i = 0; i < MyConf->Enumerate("alias"); i++)
  50                         {
  51                                 Alias a;
  52                                 std::string txt;
  53                                 txt = MyConf->ReadValue("alias", "text", i);
  54                                 a.text = txt.c_str();
  55                                 a.replace_with = MyConf->ReadValue("alias", "replace", i);
  56                                 a.requires = MyConf->ReadValue("alias", "requires", i);
  57
  58                                 a.uline =       ((MyConf->ReadValue("alias", "uline", i) == "yes") ||
  59                                                 (MyConf->ReadValue("alias", "uline", i) == "1") ||
  60                                                 (MyConf->ReadValue("alias", "uline", i) == "true"));
  61
  62                                 Aliases.push_back(a);
  63                         }
  64
  65                 }
  66
  67         public:
  68
  69                 ModuleAlias(Server* Me)
  70                         : Module::Module(Me)
  71                 {
  72                         Srv = Me;
  73                         MyConf = new ConfigReader;
  74                         ReadAliases();
  75                 }
  76
  77                 virtual ~ModuleAlias()
  78                 {
  79                         delete MyConf;
  80                 }
  81
  82                 virtual Version GetVersion()
  83                 {
  84                         return Version(1,0,0,1,VF_VENDOR);
  85                 }
  86
  87                 virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user)
  88                 {
  89                         userrec *u = NULL;
  90                         irc::string c = command.c_str();
  91
  92                         for (unsigned int i = 0; i < Aliases.size(); i++)
  93                         {
  94                                 log(DEBUG,"Check against alias %s: %s",Aliases[i].text.c_str(),c.c_str());
  95                                 if (Aliases[i].text == c)
  96                                 {
  97                                         if (Aliases[i].requires != "")
  98                                         {
  99                                                 u = Srv->FindNick(Aliases[i].requires);
 100                                         }
 101
 102                                         if ((Aliases[i].requires != "") && (!u))
 103                                         {
 104                                                 Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
 105                                                 return 1;
 106                                         }
 107                                         if (Aliases[i].uline)
 108                                         {
 109                                                 if (!Srv->IsUlined(u->server))
 110                                                 {
 111                                                         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!");
 112                                                         Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is an imposter! Please inform an IRC operator as soon as possible.");
 113                                                         return 1;
 114                                                 }
 115                                         }
 116
 117                                         std::stringstream stuff(Aliases[i].replace_with);
 118                                         for (int j = 1; j < pcnt; j++)
 119                                         {
 120                                                 if (j)
 121                                                         stuff << " ";
 122                                                 stuff << parameters[j];
 123                                         }
 124
 125                                         std::vector<std::string> items;
 126                                         while (!stuff.eof())
 127                                         {
 128                                                 std::string data;
 129                                                 stuff >> data;
 130                                                 items.push_back(data);
 131                                         }
 132
 133                                         char* para[127];
 134
 135                                         for (unsigned int j = 1; j < items.size(); j++)
 136                                                 para[j-1] = (char*)items[j].c_str();
 137
 138                                         Srv->CallCommandHandler(items[0],para,items.size()-1,user);
 139                                         return 1;
 140                                 }
 141                         }
 142                         return 0;
 143                 }
 144
 145                 virtual void OnRehash(std::string parameter)
 146                 {
 147                         delete MyConf;
 148                         MyConf = new ConfigReader;
 149
 150                         ReadAliases();
 151                 }
 152 };
 153
 154
 155 class ModuleAliasFactory : public ModuleFactory
 156 {
 157         public:
 158                 ModuleAliasFactory()
 159                 {
 160                 }
 161
 162                 ~ModuleAliasFactory()
 163                 {
 164                 }
 165
 166                 virtual Module * CreateModule(Server* Me)
 167                 {
 168                         return new ModuleAlias(Me);
 169                 }
 170 };
 171
 172
 173 extern "C" void * init_module( void )
 174 {
 175         return new ModuleAliasFactory;
 176 }
 177