X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules.cpp;h=d2f01297781c3ef270e9262ece46abd3e7dff679;hb=deb5dd0dd3b9aeacc544080569c57dacb6cad9de;hp=75149aad09b0e9a4ef221ebca9deba5d3b8b54bb;hpb=61b45c935dbb50c280970c9f431fd1c7ef4eb680;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules.cpp b/src/modules.cpp index 75149aad0..d2f012977 100644 --- a/src/modules.cpp +++ b/src/modules.cpp @@ -9,19 +9,24 @@ #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; - 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) { }; + 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 std::vector ExtModeList; @@ -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,9 +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) { - EMode.push_back( ExtMode (modechar,type,default_on,params_on,params_off)); + if (ModeDefined(modechar,type)) { + return false; + } + EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off)); return true; } @@ -84,11 +108,6 @@ Version::Version(int major, int minor, int revision, int build) : Major(major), Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { }; -// -// Announce to the world that the Module base -// class has been created or destroyed -// - Module::Module() { } Module::~Module() { } void Module::OnUserConnect(userrec* user) { } @@ -98,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(std::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 @@ -119,11 +145,65 @@ void Server::SendOpers(std::string s) WriteOpers("%s",s.c_str()); } +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::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()); @@ -141,7 +221,16 @@ void Server::SendFrom(int Socket, userrec* User, std::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, std::string s,bool IncludeSender) @@ -175,7 +264,17 @@ void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) void Server::SendWallops(userrec* User, std::string text) { - WriteWallOps(User,"%s",text.c_str()); + WriteWallOps(User,false,"%s",text.c_str()); +} + +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) @@ -215,41 +314,77 @@ 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(std::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); +}; 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); - return val; + 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(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; } @@ -271,10 +406,23 @@ void FileReader::LoadFile(std::string filename) this->fc = c; } + FileReader::~FileReader() { } +bool FileReader::Exists() +{ + if (fc.size() == 0) + { + return(false); + } + else + { + return(true); + } +} + std::string FileReader::GetLine(int x) { if ((x<0) || (x>fc.size()))