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

Generated on Wed Apr 7 19:20:14 2004 for InspIRCd by doxygen1.3-rc3