src/modules.cpp

   1 /*
   2
   3
   4 */
   5
   6
   7
   8 #include <typeinfo>
   9 #include <iostream.h>
  10 #include "globals.h"
  11 #include "modules.h"
  12 #include "inspircd_io.h"
  13
  14 // class type for holding an extended mode character - internal to core
  15
  16 class ExtMode
  17 {
  18 public:
  19         char modechar;
  20         int type;
  21         bool default_on;
  22         int params_when_on;
  23         int params_when_off;
  24         void SetInfo(char mc, int ty, bool d_on, int p_on, int p_off) : modechar(mc), type(ty), default_on(d_on), params_when_on(p_on), params_when_off(p_off) { };
  25 };
  26
  27 typedef vector<ExtMode> ExtModeList;
  28 typedef ExtModeList::iterator ExtModeListIter;
  29
  30 ExtModeList EMode;
  31
  32 // returns true if an extended mode character is in use
  33 bool ModeDefined(char modechar, int type)
  34 {
  35         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
  36         {
  37                 if ((i->modechar == modechar) && (i->type == type))
  38                 {
  39                         return true;
  40                 }
  41         }
  42         return false;
  43 }
  44
  45 // returns number of parameters for a custom mode when it is switched on
  46 int ModeDefinedOn(char modechar, int type)
  47 {
  48         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
  49         {
  50                 if ((i->modechar == modechar) && (i->type == type))
  51                 {
  52                         return i->params_when_on;
  53                 }
  54         }
  55         return 0;
  56 }
  57
  58 // returns number of parameters for a custom mode when it is switched on
  59 int ModeDefinedOff(char modechar, int type)
  60 {
  61         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
  62         {
  63                 if ((i->modechar == modechar) && (i->type == type))
  64                 {
  65                         return i->params_when_off;
  66                 }
  67         }
  68         return 0;
  69 }
  70
  71 // returns true if an extended mode character is in use
  72 bool AddExtendedMode(char modechar, int type, bool default_on, int params_on, int params_off)
  73 {
  74         ExtMode Mode;
  75         Mode.SetInfo(modechar,type,default_on,params_on,params_off);
  76         EMode.push_back(Mode);
  77         return true;
  78 }
  79
  80
  81 // version is a simple class for holding a modules version number
  82
  83 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
  84
  85 // admin is a simple class for holding a server's administrative info
  86
  87 Admin::Admin(string name, string email, string nick) : Name(name), Email(email), Nick(nick) { };
  88
  89 //
  90 // Announce to the world that the Module base
  91 // class has been created or destroyed
  92 //
  93
  94 Module::Module() { }
  95 Module::~Module() { }
  96 void Module::OnUserConnect(userrec* user) { }
  97 void Module::OnUserQuit(userrec* user) { }
  98 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
  99 void Module::OnUserPart(userrec* user, chanrec* channel) { }
 100 void Module::OnPacketTransmit(char *p) { }
 101 void Module::OnPacketReceive(char *p) { }
 102 void Module::OnRehash() { }
 103 void Module::OnServerRaw(string &raw, bool inbound) { }
 104 bool Module::OnExtendedMode(userrec* user, chanrec* chan, char modechar, int type, bool mode_on, string_list &params) { }
 105 Version Module::GetVersion() { return Version(1,0,0,0); }
 106
 107 // server is a wrapper class that provides methods to all of the C-style
 108 // exports in the core
 109 //
 110
 111 Server::Server()
 112 {
 113 }
 114
 115 Server::~Server()
 116 {
 117 }
 118
 119 void Server::SendOpers(string s)
 120 {
 121         WriteOpers("%s",s.c_str());
 122 }
 123
 124 void Server::Log(int level, string s)
 125 {
 126         log(level,"%s",s.c_str());
 127 }
 128
 129 void Server::Send(int Socket, string s)
 130 {
 131         Write(Socket,"%s",s.c_str());
 132 }
 133
 134 void Server::SendServ(int Socket, string s)
 135 {
 136         WriteServ(Socket,"%s",s.c_str());
 137 }
 138
 139 void Server::SendFrom(int Socket, userrec* User, string s)
 140 {
 141         WriteFrom(Socket,User,"%s",s.c_str());
 142 }
 143
 144 void Server::SendTo(userrec* Source, userrec* Dest, string s)
 145 {
 146         WriteTo(Source,Dest,"%s",s.c_str());
 147 }
 148
 149 void Server::SendChannel(userrec* User, chanrec* Channel, string s,bool IncludeSender)
 150 {
 151         if (IncludeSender)
 152         {
 153                 WriteChannel(Channel,User,"%s",s.c_str());
 154         }
 155         else
 156         {
 157                 ChanExceptSender(Channel,User,"%s",s.c_str());
 158         }
 159 }
 160
 161 bool Server::CommonChannels(userrec* u1, userrec* u2)
 162 {
 163         return (common_channels(u1,u2) != 0);
 164 }
 165
 166 void Server::SendCommon(userrec* User, string text,bool IncludeSender)
 167 {
 168         if (IncludeSender)
 169         {
 170                 WriteCommon(User,"%s",text.c_str());
 171         }
 172         else
 173         {
 174                 WriteCommonExcept(User,"%s",text.c_str());
 175         }
 176 }
 177
 178 void Server::SendWallops(userrec* User, string text)
 179 {
 180         WriteWallOps(User,"%s",text.c_str());
 181 }
 182
 183 bool Server::IsNick(string nick)
 184 {
 185         return (isnick(nick.c_str()) != 0);
 186 }
 187
 188 userrec* Server::FindNick(string nick)
 189 {
 190         return Find(nick);
 191 }
 192
 193 chanrec* Server::FindChannel(string channel)
 194 {
 195         return FindChan(channel.c_str());
 196 }
 197
 198 string Server::ChanMode(userrec* User, chanrec* Chan)
 199 {
 200         string mode = cmode(User,Chan);
 201         return mode;
 202 }
 203
 204 string Server::GetServerName()
 205 {
 206         return getservername();
 207 }
 208
 209 string Server::GetNetworkName()
 210 {
 211         return getnetworkname();
 212 }
 213
 214 Admin Server::GetAdmin()
 215 {
 216         return Admin(getadminname(),getadminemail(),getadminnick());
 217 }
 218
 219
 220
 221 bool Server::AddExtendedMode(char modechar, int type, bool default_on, int params_when_on, int params_when_off)
 222 {
 223 }
 224
 225
 226 ConfigReader::ConfigReader()
 227 {
 228         fname = CONFIG_FILE;
 229 }
 230
 231
 232 ConfigReader::~ConfigReader()
 233 {
 234 }
 235
 236
 237 ConfigReader::ConfigReader(string filename) : fname(filename) { };
 238
 239 string ConfigReader::ReadValue(string tag, string name, int index)
 240 {
 241         char val[MAXBUF];
 242         ReadConf(fname.c_str(),tag.c_str(),name.c_str(),index,val);
 243         string s = val;
 244         return s;
 245 }
 246
 247
 248 int ConfigReader::Enumerate(string tag)
 249 {
 250         return EnumConf(fname.c_str(),tag.c_str());
 251 }
 252
 253
 254 bool ConfigReader::Verify()
 255 {
 256         return true;
 257 }
 258
 259
 260 FileReader::FileReader(string filename)
 261 {
 262         file_cache c;
 263         readfile(c,filename.c_str());
 264         this->fc = c;
 265 }
 266
 267 FileReader::FileReader()
 268 {
 269 }
 270
 271 void FileReader::LoadFile(string filename)
 272 {
 273         file_cache c;
 274         readfile(c,filename.c_str());
 275         this->fc = c;
 276 }
 277
 278 FileReader::~FileReader()
 279 {
 280 }
 281
 282 string FileReader::GetLine(int x)
 283 {
 284         if ((x<0) || (x>fc.size()))
 285                 return "";
 286         return fc[x];
 287 }
 288
 289 int FileReader::FileSize()
 290 {
 291         return fc.size();
 292 }
 293
 294
 295 vector<Module*> modules(255);
 296 vector<ircd_module*> factory(255);
 297
 298 int MODCOUNT  = -1;
 299
 300