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 #include "users.h"
  18 #include "channels.h"
  19 #include "modules.h"
  20 #include <vector>
  21
  22 /* $ModDesc: Changes the ident of connecting bottler clients to 'bottler' */
  23
  24 class Alias
  25 {
  26  public:
  27         std::string text;
  28         std::string replace_with;
  29         std::string requires;
  30         bool uline;
  31 };
  32
  33 class ModuleAlias : public Module
  34 {
  35  private:
  36
  37          Server *Srv;
  38          ConfigReader *MyConf;
  39          std::vector<Alias> Aliases;
  40  public:
  41
  42         virtual void ReadAliases()
  43         {
  44                 Aliases.clear();
  45
  46                 for (int i = 0; i < MyConf->Enumerate("alias"); i++)
  47                 {
  48                         Alias a;
  49                         a.text = MyConf->ReadValue("alias", "text", i);
  50                         a.replace_with = MyConf->ReadValue("alias", "replace", i);
  51                         a.requires = MyConf->ReadValue("alias", "requires", i);
  52
  53                         a.uline =       ((MyConf->ReadValue("alias", "uline", i) == "yes") ||
  54                                         (MyConf->ReadValue("alias", "uline", i) == "1") ||
  55                                         (MyConf->ReadValue("alias", "uline", i) == "true"));
  56
  57                         Aliases.push_back(a);
  58                 }
  59
  60         }
  61
  62         ModuleAlias()
  63         {
  64                 Srv = new Server;
  65                 MyConf = new ConfigReader;
  66
  67                 ReadAliases();
  68         }
  69
  70         virtual ~ModuleAlias()
  71         {
  72                 delete Srv;
  73                 delete MyConf;
  74         }
  75
  76         virtual Version GetVersion()
  77         {
  78                 return Version(1,0,0,0,0);
  79         }
  80
  81
  82         virtual void OnServerRaw(std::string &raw, bool inbound, userrec* user)
  83         {
  84                 if (inbound)
  85                 {
  86                         char data[MAXBUF];
  87                         strncpy(data,raw.c_str(),MAXBUF);
  88                         char* dptr = data;
  89
  90                         for (int i = 0; i < Aliases.size(); i++)
  91                         {
  92                                 if (!strncasecmp(Aliases[i].text.c_str(),data,Aliases[i].text.length()))
  93                                 {
  94                                         userrec* u = NULL;
  95
  96                                         if (Aliases[i].requires != "")
  97                                         {
  98                                                 u = Srv->FindNick(Aliases[i].requires);
  99                                         }
 100
 101                                         if ((Aliases[i].requires != "") && (!u))
 102                                         {
 103                                                 Srv->SendServ(user->fd,"401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
 104                                                 raw = "PONG :"+Srv->GetServerName();
 105                                                 return;
 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 "+Aliases[i].text+" 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                                                         raw = "PONG :"+Srv->GetServerName();
 114                                                         return;
 115                                                 }
 116                                         }
 117
 118                                         dptr += Aliases[i].text.length();
 119                                         if (strlen(dptr))
 120                                         {
 121                                                 raw = Aliases[i].replace_with + std::string(dptr);
 122                                         }
 123                                         else
 124                                         {
 125                                                 raw = Aliases[i].replace_with;
 126                                         }
 127                                         return;
 128                                 }
 129                         }
 130                 }
 131         }
 132
 133         virtual void OnRehash()
 134         {
 135                 delete MyConf;
 136                 MyConf = new ConfigReader;
 137
 138                 ReadAliases();
 139         }
 140 };
 141
 142
 143 class ModuleAliasFactory : public ModuleFactory
 144 {
 145  public:
 146         ModuleAliasFactory()
 147         {
 148         }
 149
 150         ~ModuleAliasFactory()
 151         {
 152         }
 153
 154         virtual Module * CreateModule()
 155         {
 156                 return new ModuleAlias;
 157         }
 158
 159 };
 160
 161
 162 extern "C" void * init_module( void )
 163 {
 164         return new ModuleAliasFactory;
 165 }
 166