src/modules.cpp

   1 /*
   2
   3
   4 */
   5
   6
   7
   8 #include <typeinfo>
   9 #include <iostream>
  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         ExtMode(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 std::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         EMode.push_back( ExtMode (modechar,type,default_on,params_on,params_off));
  75         return true;
  76 }
  77
  78
  79 // version is a simple class for holding a modules version number
  80
  81 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
  82
  83 // admin is a simple class for holding a server's administrative info
  84
  85 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
  86
  87 //
  88 // Announce to the world that the Module base
  89 // class has been created or destroyed
  90 //
  91
  92 Module::Module() { }
  93 Module::~Module() { }
  94 void Module::OnUserConnect(userrec* user) { }
  95 void Module::OnUserQuit(userrec* user) { }
  96 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
  97 void Module::OnUserPart(userrec* user, chanrec* channel) { }
  98 void Module::OnPacketTransmit(char *p) { }
  99 void Module::OnPacketReceive(char *p) { }
 100 void Module::OnRehash() { }
 101 void Module::OnServerRaw(std::string &raw, bool inbound) { }
 102 bool Module::OnExtendedMode(userrec* user, chanrec* chan, char modechar, int type, bool mode_on, string_list &params) { }
 103 Version Module::GetVersion() { return Version(1,0,0,0); }
 104
 105 // server is a wrapper class that provides methods to all of the C-style
 106 // exports in the core
 107 //
 108
 109 Server::Server()
 110 {
 111 }
 112
 113 Server::~Server()
 114 {
 115 }
 116
 117 void Server::SendOpers(std::string s)
 118 {
 119         WriteOpers("%s",s.c_str());
 120 }
 121
 122 void Server::Log(int level, std::string s)
 123 {
 124         log(level,"%s",s.c_str());
 125 }
 126
 127 void Server::Send(int Socket, std::string s)
 128 {
 129         Write(Socket,"%s",s.c_str());
 130 }
 131
 132 void Server::SendServ(int Socket, std::string s)
 133 {
 134         WriteServ(Socket,"%s",s.c_str());
 135 }
 136
 137 void Server::SendFrom(int Socket, userrec* User, std::string s)
 138 {
 139         WriteFrom(Socket,User,"%s",s.c_str());
 140 }
 141
 142 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
 143 {
 144         WriteTo(Source,Dest,"%s",s.c_str());
 145 }
 146
 147 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
 148 {
 149         if (IncludeSender)
 150         {
 151                 WriteChannel(Channel,User,"%s",s.c_str());
 152         }
 153         else
 154         {
 155                 ChanExceptSender(Channel,User,"%s",s.c_str());
 156         }
 157 }
 158
 159 bool Server::CommonChannels(userrec* u1, userrec* u2)
 160 {
 161         return (common_channels(u1,u2) != 0);
 162 }
 163
 164 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
 165 {
 166         if (IncludeSender)
 167         {
 168                 WriteCommon(User,"%s",text.c_str());
 169         }
 170         else
 171         {
 172                 WriteCommonExcept(User,"%s",text.c_str());
 173         }
 174 }
 175
 176 void Server::SendWallops(userrec* User, std::string text)
 177 {
 178         WriteWallOps(User,"%s",text.c_str());
 179 }
 180
 181 bool Server::IsNick(std::string nick)
 182 {
 183         return (isnick(nick.c_str()) != 0);
 184 }
 185
 186 userrec* Server::FindNick(std::string nick)
 187 {
 188         return Find(nick);
 189 }
 190
 191 chanrec* Server::FindChannel(std::string channel)
 192 {
 193         return FindChan(channel.c_str());
 194 }
 195
 196 std::string Server::ChanMode(userrec* User, chanrec* Chan)
 197 {
 198         return cmode(User,Chan);
 199 }
 200
 201 std::string Server::GetServerName()
 202 {
 203         return getservername();
 204 }
 205
 206 std::string Server::GetNetworkName()
 207 {
 208         return getnetworkname();
 209 }
 210
 211 Admin Server::GetAdmin()
 212 {
 213         return Admin(getadminname(),getadminemail(),getadminnick());
 214 }
 215
 216
 217
 218 bool Server::AddExtendedMode(char modechar, int type, bool default_on, int params_when_on, int params_when_off)
 219 {
 220 }
 221
 222
 223 ConfigReader::ConfigReader()
 224 {
 225         fname = CONFIG_FILE;
 226 }
 227
 228
 229 ConfigReader::~ConfigReader()
 230 {
 231 }
 232
 233
 234 ConfigReader::ConfigReader(std::string filename) : fname(filename) { };
 235
 236 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
 237 {
 238         char val[MAXBUF];
 239         ReadConf(fname.c_str(),tag.c_str(),name.c_str(),index,val);
 240         return val;
 241 }
 242
 243
 244 int ConfigReader::Enumerate(std::string tag)
 245 {
 246         return EnumConf(fname.c_str(),tag.c_str());
 247 }
 248
 249
 250 bool ConfigReader::Verify()
 251 {
 252         return true;
 253 }
 254
 255
 256 FileReader::FileReader(std::string filename)
 257 {
 258         file_cache c;
 259         readfile(c,filename.c_str());
 260         this->fc = c;
 261 }
 262
 263 FileReader::FileReader()
 264 {
 265 }
 266
 267 void FileReader::LoadFile(std::string filename)
 268 {
 269         file_cache c;
 270         readfile(c,filename.c_str());
 271         this->fc = c;
 272 }
 273
 274
 275 FileReader::~FileReader()
 276 {
 277 }
 278
 279 bool FileReader::Exists()
 280 {
 281         if (fc.size() == 0)
 282         {
 283                 return(false);
 284         }
 285         else
 286         {
 287                 return(true);
 288         }
 289 }
 290
 291 std::string FileReader::GetLine(int x)
 292 {
 293         if ((x<0) || (x>fc.size()))
 294                 return "";
 295         return fc[x];
 296 }
 297
 298 int FileReader::FileSize()
 299 {
 300         return fc.size();
 301 }
 302
 303
 304 std::vector<Module*> modules(255);
 305 std::vector<ircd_module*> factory(255);
 306
 307 int MODCOUNT  = -1;
 308
 309