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: Changes the ident of connecting bottler clients to 'bottler' */
  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
  39          Server *Srv;
  40          ConfigReader *MyConf;
  41          std::vector<Alias> Aliases;
  42  public:
  43
  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         ModuleAlias()
  65         {
  66                 Srv = new Server;
  67                 MyConf = new ConfigReader;
  68
  69                 ReadAliases();
  70         }
  71
  72         virtual ~ModuleAlias()
  73         {
  74                 delete Srv;
  75                 delete MyConf;
  76         }
  77
  78         virtual Version GetVersion()
  79         {
  80                 return Version(1,0,0,1,VF_VENDOR);
  81         }
  82
  83
  84         virtual void OnServerRaw(std::string &raw, bool inbound, userrec* user)
  85         {
  86                 if (inbound)
  87                 {
  88                         char data[MAXBUF];
  89                         strncpy(data,raw.c_str(),MAXBUF);
  90                         char* dptr = data;
  91
  92                         for (int i = 0; i < Aliases.size(); i++)
  93                         {
  94                                 if (!strncasecmp(Aliases[i].text.c_str(),data,Aliases[i].text.length()))
  95                                 {
  96                                         userrec* u = NULL;
  97
  98                                         if (Aliases[i].requires != "")
  99                                         {
 100                                                 u = Srv->FindNick(Aliases[i].requires);
 101                                         }
 102
 103                                         if ((Aliases[i].requires != "") && (!u))
 104                                         {
 105                                                 Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
 106                                                 raw = "PONG :"+Srv->GetServerName();
 107                                                 return;
 108                                         }
 109                                         if (Aliases[i].uline)
 110                                         {
 111                                                 if (!Srv->IsUlined(u->server))
 112                                                 {
 113                                                         Srv->SendOpers("*** NOTICE -- Service "+Aliases[i].requires+" required by alias "+Aliases[i].text+" is not on a u-lined server, possibly underhanded antics detected!");
 114                                                         Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is an imposter! Please inform an IRC operator as soon as possible.");
 115                                                         raw = "PONG :"+Srv->GetServerName();
 116                                                         return;
 117                                                 }
 118                                         }
 119
 120                                         dptr += Aliases[i].text.length();
 121                                         if (strlen(dptr))
 122                                         {
 123                                                 raw = Aliases[i].replace_with + std::string(dptr);
 124                                         }
 125                                         else
 126                                         {
 127                                                 raw = Aliases[i].replace_with;
 128                                         }
 129                                         return;
 130                                 }
 131                         }
 132                 }
 133         }
 134
 135         virtual void OnRehash()
 136         {
 137                 delete MyConf;
 138                 MyConf = new ConfigReader;
 139
 140                 ReadAliases();
 141         }
 142 };
 143
 144
 145 class ModuleAliasFactory : public ModuleFactory
 146 {
 147  public:
 148         ModuleAliasFactory()
 149         {
 150         }
 151
 152         ~ModuleAliasFactory()
 153         {
 154         }
 155
 156         virtual Module * CreateModule()
 157         {
 158                 return new ModuleAlias;
 159         }
 160
 161 };
 162
 163
 164 extern "C" void * init_module( void )
 165 {
 166         return new ModuleAliasFactory;
 167 }
 168