Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

modules.cpp

Go to the documentation of this file.
00001 /*
00002 
00003 
00004 */
00005 
00006 
00007 
00008 #include <typeinfo>
00009 #include <iostream>
00010 #include "globals.h"
00011 #include "modules.h"
00012 #include "ctables.h"
00013 #include "inspircd_io.h"
00014 
00015 // class type for holding an extended mode character - internal to core
00016 
00017 class ExtMode
00018 {
00019 public:
00020         char modechar;
00021         int type;
00022         int params_when_on;
00023         int params_when_off;
00024         bool needsoper;
00025         ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off) { };
00026 };                                     
00027 
00028 typedef std::vector<ExtMode> ExtModeList;
00029 typedef ExtModeList::iterator ExtModeListIter;
00030 
00031 ExtModeList EMode;
00032 
00033 // returns true if an extended mode character is in use
00034 bool ModeDefined(char modechar, int type)
00035 {
00036         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
00037         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00038         {
00039                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
00040                 if ((i->modechar == modechar) && (i->type == type))
00041                 {
00042                         return true;
00043                 }
00044         }
00045         return false;
00046 }
00047 
00048 bool ModeDefinedOper(char modechar, int type)
00049 {
00050         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
00051         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00052         {
00053                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
00054                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
00055                 {
00056                         return true;
00057                 }
00058         }
00059         return false;
00060 }
00061 
00062 // returns number of parameters for a custom mode when it is switched on
00063 int ModeDefinedOn(char modechar, int type)
00064 {
00065         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00066         {
00067                 if ((i->modechar == modechar) && (i->type == type))
00068                 {
00069                         return i->params_when_on;
00070                 }
00071         }
00072         return 0;
00073 }
00074 
00075 // returns number of parameters for a custom mode when it is switched on
00076 int ModeDefinedOff(char modechar, int type)
00077 {
00078         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00079         {
00080                 if ((i->modechar == modechar) && (i->type == type))
00081                 {
00082                         return i->params_when_off;
00083                 }
00084         }
00085         return 0;
00086 }
00087 
00088 // returns true if an extended mode character is in use
00089 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
00090 {
00091         if (ModeDefined(modechar,type)) {
00092                 return false;
00093         }
00094         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
00095         return true;
00096 }
00097 
00098 
00099 // version is a simple class for holding a modules version number
00100 
00101 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
00102 
00103 // admin is a simple class for holding a server's administrative info
00104 
00105 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
00106 
00107 Module::Module() { }
00108 Module::~Module() { }
00109 void Module::OnUserConnect(userrec* user) { }
00110 void Module::OnUserQuit(userrec* user) { }
00111 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
00112 void Module::OnUserPart(userrec* user, chanrec* channel) { }
00113 void Module::OnPacketTransmit(char *p) { }
00114 void Module::OnPacketReceive(char *p) { }
00115 void Module::OnRehash() { }
00116 void Module::OnServerRaw(std::string &raw, bool inbound) { }
00117 int Module::OnUserPreJoin(userrec* user, chanrec* chan, char* cname) { return 0; }
00118 bool Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { }
00119 Version Module::GetVersion() { return Version(1,0,0,0); }
00120 
00121 // server is a wrapper class that provides methods to all of the C-style
00122 // exports in the core
00123 //
00124 
00125 Server::Server()
00126 {
00127 }
00128 
00129 Server::~Server()
00130 {
00131 }
00132 
00133 void Server::SendOpers(std::string s)
00134 {
00135         WriteOpers("%s",s.c_str());
00136 }
00137 
00138 void Server::Log(int level, std::string s)
00139 {
00140         log(level,"%s",s.c_str());
00141 }
00142 
00143 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
00144 {
00145         createcommand(cmd,f,flags,minparams);
00146 }
00147 
00148 void Server::SendMode(char **parameters, int pcnt, userrec *user)
00149 {
00150         server_mode(parameters,pcnt,user);
00151 }
00152 
00153 void Server::Send(int Socket, std::string s)
00154 {
00155         Write(Socket,"%s",s.c_str());
00156 }
00157 
00158 void Server::SendServ(int Socket, std::string s)
00159 {
00160         WriteServ(Socket,"%s",s.c_str());
00161 }
00162 
00163 void Server::SendFrom(int Socket, userrec* User, std::string s)
00164 {
00165         WriteFrom(Socket,User,"%s",s.c_str());
00166 }
00167 
00168 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
00169 {
00170         WriteTo(Source,Dest,"%s",s.c_str());
00171 }
00172 
00173 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
00174 {
00175         if (IncludeSender)
00176         {
00177                 WriteChannel(Channel,User,"%s",s.c_str());
00178         }
00179         else
00180         {
00181                 ChanExceptSender(Channel,User,"%s",s.c_str());
00182         }
00183 }
00184 
00185 bool Server::CommonChannels(userrec* u1, userrec* u2)
00186 {
00187         return (common_channels(u1,u2) != 0);
00188 }
00189 
00190 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
00191 {
00192         if (IncludeSender)
00193         {
00194                 WriteCommon(User,"%s",text.c_str());
00195         }
00196         else
00197         {
00198                 WriteCommonExcept(User,"%s",text.c_str());
00199         }
00200 }
00201 
00202 void Server::SendWallops(userrec* User, std::string text)
00203 {
00204         WriteWallOps(User,"%s",text.c_str());
00205 }
00206 
00207 bool Server::IsNick(std::string nick)
00208 {
00209         return (isnick(nick.c_str()) != 0);
00210 }
00211 
00212 userrec* Server::FindNick(std::string nick)
00213 {
00214         return Find(nick);
00215 }
00216 
00217 chanrec* Server::FindChannel(std::string channel)
00218 {
00219         return FindChan(channel.c_str());
00220 }
00221 
00222 std::string Server::ChanMode(userrec* User, chanrec* Chan)
00223 {
00224         return cmode(User,Chan);
00225 }
00226 
00227 std::string Server::GetServerName()
00228 {
00229         return getservername();
00230 }
00231 
00232 std::string Server::GetNetworkName()
00233 {
00234         return getnetworkname();
00235 }
00236 
00237 Admin Server::GetAdmin()
00238 {
00239         return Admin(getadminname(),getadminemail(),getadminnick());
00240 }
00241 
00242 
00243 
00244 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
00245 {
00246         if (type == MT_SERVER)
00247         {
00248                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
00249                 return false;
00250         }
00251         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
00252         {
00253                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
00254                 return false;
00255         }
00256         if ((params_when_on>1) || (params_when_off>1))
00257         {
00258                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
00259                 return false;
00260         }
00261         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
00262 }
00263 
00264 
00265 ConfigReader::ConfigReader()
00266 {
00267         fname = CONFIG_FILE;
00268 }
00269 
00270 
00271 ConfigReader::~ConfigReader()
00272 {
00273 }
00274 
00275 
00276 ConfigReader::ConfigReader(std::string filename) : fname(filename) { };
00277 
00278 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
00279 {
00280         char val[MAXBUF];
00281         ReadConf(fname.c_str(),tag.c_str(),name.c_str(),index,val);
00282         return val;
00283 }
00284 
00285 
00286 int ConfigReader::Enumerate(std::string tag)
00287 {
00288         return EnumConf(fname.c_str(),tag.c_str());
00289 }
00290 
00291 
00292 bool ConfigReader::Verify()
00293 {
00294         return true;
00295 }
00296 
00297 
00298 FileReader::FileReader(std::string filename)
00299 {
00300         file_cache c;
00301         readfile(c,filename.c_str());
00302         this->fc = c;
00303 }
00304 
00305 FileReader::FileReader()
00306 {
00307 }
00308 
00309 void FileReader::LoadFile(std::string filename)
00310 {
00311         file_cache c;
00312         readfile(c,filename.c_str());
00313         this->fc = c;
00314 }
00315 
00316 
00317 FileReader::~FileReader()
00318 {
00319 }
00320 
00321 bool FileReader::Exists()
00322 {
00323         if (fc.size() == 0)
00324         {
00325                 return(false);
00326         }
00327         else
00328         {
00329                 return(true);
00330         }
00331 }
00332 
00333 std::string FileReader::GetLine(int x)
00334 {
00335         if ((x<0) || (x>fc.size()))
00336                 return "";
00337         return fc[x];
00338 }
00339 
00340 int FileReader::FileSize()
00341 {
00342         return fc.size();
00343 }
00344 
00345 
00346 std::vector<Module*> modules(255);
00347 std::vector<ircd_module*> factory(255);
00348 
00349 int MODCOUNT  = -1;
00350 
00351 

Generated on Mon Apr 5 02:03:51 2004 for InspIRCd by doxygen1.3-rc3