X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules.cpp;h=d2f01297781c3ef270e9262ece46abd3e7dff679;hb=deb5dd0dd3b9aeacc544080569c57dacb6cad9de;hp=34c9bf125e6709985dfffdb4f7e5455f247f7951;hpb=e1cc6b33f4e5510f65d8cfeb62b0f31d567e1bbf;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules.cpp b/src/modules.cpp index 34c9bf125..d2f012977 100644 --- a/src/modules.cpp +++ b/src/modules.cpp @@ -6,25 +6,30 @@ #include -#include +#include #include "globals.h" #include "modules.h" +#include "ctables.h" #include "inspircd_io.h" +#include "wildcard.h" +#include "mode.h" +#include "message.h" +#include "commands.h" // class type for holding an extended mode character - internal to core -class ExtMode +class ExtMode : public classbase { public: char modechar; int type; - bool default_on; int params_when_on; int params_when_off; - 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) { }; + bool needsoper; + 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) { }; }; -typedef vector ExtModeList; +typedef std::vector ExtModeList; typedef ExtModeList::iterator ExtModeListIter; ExtModeList EMode; @@ -32,8 +37,10 @@ ExtModeList EMode; // returns true if an extended mode character is in use bool ModeDefined(char modechar, int type) { + log(DEBUG,"Size of extmodes vector is %d",EMode.size()); for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) { + log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type); if ((i->modechar == modechar) && (i->type == type)) { return true; @@ -42,6 +49,20 @@ bool ModeDefined(char modechar, int type) return false; } +bool ModeDefinedOper(char modechar, int type) +{ + log(DEBUG,"Size of extmodes vector is %d",EMode.size()); + for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) + { + log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type); + if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true)) + { + return true; + } + } + return false; +} + // returns number of parameters for a custom mode when it is switched on int ModeDefinedOn(char modechar, int type) { @@ -69,11 +90,12 @@ int ModeDefinedOff(char modechar, int type) } // returns true if an extended mode character is in use -bool AddExtendedMode(char modechar, int type, bool default_on, int params_on, int params_off) +bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off) { - ExtMode Mode; - Mode.SetInfo(modechar,type,default_on,params_on,params_off); - EMode.push_back(Mode); + if (ModeDefined(modechar,type)) { + return false; + } + EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off)); return true; } @@ -84,12 +106,7 @@ Version::Version(int major, int minor, int revision, int build) : Major(major), // admin is a simple class for holding a server's administrative info -Admin::Admin(string name, string email, string nick) : Name(name), Email(email), Nick(nick) { }; - -// -// Announce to the world that the Module base -// class has been created or destroyed -// +Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { }; Module::Module() { } Module::~Module() { } @@ -100,9 +117,16 @@ void Module::OnUserPart(userrec* user, chanrec* channel) { } void Module::OnPacketTransmit(char *p) { } void Module::OnPacketReceive(char *p) { } void Module::OnRehash() { } -void Module::OnServerRaw(string &raw, bool inbound) { } -bool Module::OnExtendedMode(userrec* user, chanrec* chan, char modechar, int type, bool mode_on, string_list ¶ms) { } +void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { } +int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; } +bool Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; } Version Module::GetVersion() { return Version(1,0,0,0); } +void Module::OnOper(userrec* user) { }; +void Module::OnInfo(userrec* user) { }; +void Module::OnWhois(userrec* source, userrec* dest) { }; +int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; }; +int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; }; +int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; }; // server is a wrapper class that provides methods to all of the C-style // exports in the core @@ -116,37 +140,100 @@ Server::~Server() { } -void Server::SendOpers(string s) +void Server::SendOpers(std::string s) { WriteOpers("%s",s.c_str()); } -void Server::Log(int level, string s) +bool Server::MatchText(std::string sliteral, std::string spattern) +{ + char literal[MAXBUF],pattern[MAXBUF]; + strncpy(literal,sliteral.c_str(),MAXBUF); + strncpy(pattern,spattern.c_str(),MAXBUF); + return match(literal,pattern); +} + +void Server::SendToModeMask(std::string modes, int flags, std::string text) +{ + WriteMode(modes.c_str(),flags,"%s",text.c_str()); +} + +chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key) +{ + return add_channel(user,cname.c_str(),key.c_str(),true); +} + +chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason) +{ + return del_channel(user,cname.c_str(),reason.c_str(),false); +} + +void Server::ChangeUserNick(userrec* user, std::string nickname) +{ + force_nickchange(user,nickname.c_str()); +} + +void Server::QuitUser(userrec* user, std::string reason) +{ + send_network_quit(user->nick,reason.c_str()); + kill_link(user,reason.c_str()); +} + +bool Server::IsUlined(std::string server) +{ + return is_uline(server.c_str()); +} + +void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user) +{ + call_handler(commandname.c_str(),parameters,pcnt,user); +} + +void Server::Log(int level, std::string s) { log(level,"%s",s.c_str()); } -void Server::Send(int Socket, string s) +void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams) +{ + createcommand(cmd,f,flags,minparams); +} + +void Server::SendMode(char **parameters, int pcnt, userrec *user) +{ + server_mode(parameters,pcnt,user); +} + +void Server::Send(int Socket, std::string s) { Write(Socket,"%s",s.c_str()); } -void Server::SendServ(int Socket, string s) +void Server::SendServ(int Socket, std::string s) { WriteServ(Socket,"%s",s.c_str()); } -void Server::SendFrom(int Socket, userrec* User, string s) +void Server::SendFrom(int Socket, userrec* User, std::string s) { WriteFrom(Socket,User,"%s",s.c_str()); } -void Server::SendTo(userrec* Source, userrec* Dest, string s) +void Server::SendTo(userrec* Source, userrec* Dest, std::string s) { - WriteTo(Source,Dest,"%s",s.c_str()); + if (!Source) + { + // if source is NULL, then the message originates from the local server + Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str()); + } + else + { + // otherwise it comes from the user specified + WriteTo(Source,Dest,"%s",s.c_str()); + } } -void Server::SendChannel(userrec* User, chanrec* Channel, string s,bool IncludeSender) +void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender) { if (IncludeSender) { @@ -163,7 +250,7 @@ bool Server::CommonChannels(userrec* u1, userrec* u2) return (common_channels(u1,u2) != 0); } -void Server::SendCommon(userrec* User, string text,bool IncludeSender) +void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) { if (IncludeSender) { @@ -175,38 +262,47 @@ void Server::SendCommon(userrec* User, string text,bool IncludeSender) } } -void Server::SendWallops(userrec* User, string text) +void Server::SendWallops(userrec* User, std::string text) { - WriteWallOps(User,"%s",text.c_str()); + WriteWallOps(User,false,"%s",text.c_str()); } -bool Server::IsNick(string nick) +void Server::ChangeHost(userrec* user, std::string host) +{ + ChangeDisplayedHost(user,host.c_str()); +} + +void Server::ChangeGECOS(userrec* user, std::string gecos) +{ + ChangeName(user,gecos.c_str()); +} + +bool Server::IsNick(std::string nick) { return (isnick(nick.c_str()) != 0); } -userrec* Server::FindNick(string nick) +userrec* Server::FindNick(std::string nick) { return Find(nick); } -chanrec* Server::FindChannel(string channel) +chanrec* Server::FindChannel(std::string channel) { return FindChan(channel.c_str()); } -string Server::ChanMode(userrec* User, chanrec* Chan) +std::string Server::ChanMode(userrec* User, chanrec* Chan) { - string mode = cmode(User,Chan); - return mode; + return cmode(User,Chan); } -string Server::GetServerName() +std::string Server::GetServerName() { return getservername(); } -string Server::GetNetworkName() +std::string Server::GetNetworkName() { return getnetworkname(); } @@ -218,46 +314,81 @@ Admin Server::GetAdmin() -bool Server::AddExtendedMode(char modechar, int type, bool default_on, int params_when_on, int params_when_off) +bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off) +{ + if (type == MT_SERVER) + { + log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion"); + return false; + } + if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT)) + { + log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported"); + return false; + } + if ((params_when_on>1) || (params_when_off>1)) + { + log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported"); + return false; + } + return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off); +} + +int Server::CountUsers(chanrec* c) { + return usercount(c); } ConfigReader::ConfigReader() { - fname = CONFIG_FILE; + this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); + this->error = LoadConf(CONFIG_FILE,this->cache); } ConfigReader::~ConfigReader() { + if (this->cache) + delete this->cache; } -ConfigReader::ConfigReader(string filename) : fname(filename) { }; +ConfigReader::ConfigReader(std::string filename) +{ + this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); + this->error = LoadConf(filename.c_str(),this->cache); +}; -string ConfigReader::ReadValue(string tag, string name, int index) +std::string ConfigReader::ReadValue(std::string tag, std::string name, int index) { char val[MAXBUF]; - ReadConf(fname.c_str(),tag.c_str(),name.c_str(),index,val); - string s = val; - return s; + char t[MAXBUF]; + char n[MAXBUF]; + strncpy(t,tag.c_str(),MAXBUF); + strncpy(n,name.c_str(),MAXBUF); + ReadConf(cache,t,n,index,val); + return std::string(val); } -int ConfigReader::Enumerate(string tag) +int ConfigReader::Enumerate(std::string tag) { - return EnumConf(fname.c_str(),tag.c_str()); + return EnumConf(cache,tag.c_str()); } +int ConfigReader::EnumerateValues(std::string tag, int index) +{ + return EnumValues(cache, tag.c_str(), index); +} bool ConfigReader::Verify() { - return true; + return this->error; } -FileReader::FileReader(string filename) +FileReader::FileReader(std::string filename) { file_cache c; readfile(c,filename.c_str()); @@ -268,18 +399,31 @@ FileReader::FileReader() { } -void FileReader::LoadFile(string filename) +void FileReader::LoadFile(std::string filename) { file_cache c; readfile(c,filename.c_str()); this->fc = c; } + FileReader::~FileReader() { } -string FileReader::GetLine(int x) +bool FileReader::Exists() +{ + if (fc.size() == 0) + { + return(false); + } + else + { + return(true); + } +} + +std::string FileReader::GetLine(int x) { if ((x<0) || (x>fc.size())) return ""; @@ -292,8 +436,8 @@ int FileReader::FileSize() } -vector modules(255); -vector factory(255); +std::vector modules(255); +std::vector factory(255); int MODCOUNT = -1;