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 <vector>
  23
  24 /* $ModDesc: Provides aliases of commands. */
  25
  26 class Alias
  27 {
  28         public:
  29                 std::string text;
  30                 std::string replace_with;
  31                 std::string requires;
  32                 bool uline;
  33 };
  34
  35 class ModuleAlias : public Module
  36 {
  37         private:
  38                 Server *Srv;
  39                 ConfigReader *MyConf;
  40                 std::vector<Alias> Aliases;
  41
  42                 /* XXX - small issue, why is this marked public when it's not (really) intended for external use
  43                  * Fixed 30/11/05 by Brain as suggestion by w00t */
  44                 virtual void ReadAliases()
  45                 {
  46                         Aliases.clear();
  47
  48                         for (int i = 0; i < MyConf->Enumerate("alias"); i++)
  49                         {
  50                                 Alias a;
  51                                 a.text = MyConf->ReadValue("alias", "text", i);
  52                                 a.replace_with = MyConf->ReadValue("alias", "replace", i);
  53                                 a.requires = MyConf->ReadValue("alias", "requires", i);
  54
  55                                 a.uline =       ((MyConf->ReadValue("alias", "uline", i) == "yes") ||
  56                                                 (MyConf->ReadValue("alias", "uline", i) == "1") ||
  57                                                 (MyConf->ReadValue("alias", "uline", i) == "true"));
  58
  59                                 Aliases.push_back(a);
  60                         }
  61
  62                 }
  63
  64         public:
  65
  66                 ModuleAlias(Server* Me)
  67                         : Module::Module(Me)
  68                 {
  69                         Srv = Me;
  70                         MyConf = new ConfigReader;
  71                         ReadAliases();
  72                 }
  73
  74                 virtual ~ModuleAlias()
  75                 {
  76                         delete MyConf;
  77                 }
  78
  79                 virtual Version GetVersion()
  80                 {
  81                         return Version(1,0,0,1,VF_VENDOR);
  82                 }
  83
  84
  85                 virtual void OnServerRaw(std::string &raw, bool inbound, userrec* user)
  86                 {
  87                         char data[MAXBUF];
  88                         char *dptr;
  89                         userrec *u = NULL;
  90
  91                         if (inbound)
  92                         {
  93                                 strncpy(data, raw.c_str(),MAXBUF);
  94                                 dptr = data;
  95
  96                                 for (unsigned int i = 0; i < Aliases.size(); i++)
  97                                 {
  98                                         if (!strncasecmp(Aliases[i].text.c_str(),data,Aliases[i].text.length()))
  99                                         {
 100                                                 if (Aliases[i].requires != "")
 101                                                 {
 102                                                         u = Srv->FindNick(Aliases[i].requires);
 103                                                 }
 104
 105                                                 if ((Aliases[i].requires != "") && (!u))
 106                                                 {
 107                                                         Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
 108                                                         raw = "PONG :"+Srv->GetServerName();
 109                                                         return;
 110                                                 }
 111                                                 if (Aliases[i].uline)
 112                                                 {
 113                                                         if (!Srv->IsUlined(u->server))
 114                                                         {
 115                                                                 Srv->SendOpers("*** NOTICE -- Service "+Aliases[i].requires+" required by alias "+Aliases[i].text+" is not on a u-lined server, possibly underhanded antics detected!");
 116                                                                 Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is an imposter! Please inform an IRC operator as soon as possible.");
 117                                                                 raw = "PONG :"+Srv->GetServerName();
 118                                                                 return;
 119                                                         }
 120                                                 }
 121
 122                                                 dptr += Aliases[i].text.length();
 123                                                 if (strlen(dptr))
 124                                                 {
 125                                                         raw = Aliases[i].replace_with + std::string(dptr);
 126                                                 }
 127                                                 else
 128                                                 {
 129                                                         raw = Aliases[i].replace_with;
 130                                                 }
 131                                                 return;
 132                                         }
 133                                 }
 134                         }
 135                 }
 136
 137                 virtual void OnRehash(std::string parameter)
 138                 {
 139                         delete MyConf;
 140                         MyConf = new ConfigReader;
 141
 142                         ReadAliases();
 143                 }
 144 };
 145
 146
 147 class ModuleAliasFactory : public ModuleFactory
 148 {
 149         public:
 150                 ModuleAliasFactory()
 151                 {
 152                 }
 153
 154                 ~ModuleAliasFactory()
 155                 {
 156                 }
 157
 158                 virtual Module * CreateModule(Server* Me)
 159                 {
 160                         return new ModuleAlias(Me);
 161                 }
 162 };
 163
 164
 165 extern "C" void * init_module( void )
 166 {
 167         return new ModuleAliasFactory;
 168 }
 169