modules.cpp Source File

00001 /*
 00002 
 00003 
@@ -14,225 +14,430 @@
 00006 
 00007 
 00008 #include <typeinfo>
-00009 #include <iostream.h>
+00009 #include <iostream>
 00010 #include "globals.h"
 00011 #include "modules.h"
-00012 #include "inspircd_io.h"
-00013 
-00014 // version is a simple class for holding a modules version number
+00012 #include "ctables.h"
+00013 #include "inspircd_io.h"
+00014 #include "wildcard.h"
 00015 
-00016 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+00016 // class type for holding an extended mode character - internal to core
 00017 
-00018 // admin is a simple class for holding a server's administrative info
-00019 
-00020 Admin::Admin(string name, string email, string nick) : Name(name), Email(email), Nick(nick) { };
-00021 
-00022 //
-00023 // Announce to the world that the Module base
-00024 // class has been created or destroyed
-00025 //
-00026 
-00027 Module::Module() { }
-00028 Module::~Module() { }
-00029 void Module::OnUserConnect(userrec* user) { }
-00030 void Module::OnUserQuit(userrec* user) { }
-00031 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-00032 void Module::OnUserPart(userrec* user, chanrec* channel) { }
-00033 void Module::OnPacketTransmit(char *p) { }
-00034 void Module::OnPacketReceive(char *p) { }
-00035 void Module::OnRehash() { }
-00036 void Module::OnServerRaw(string &raw, bool inbound) { }
-00037 Version Module::GetVersion() { return Version(1,0,0,0); }
-00038 
-00039 // server is a wrapper class that provides methods to all of the C-style
-00040 // exports in the core
-00041 //
-00042 
-00043 Server::Server()
-00044 {
-00045 }
-00046 
-00047 Server::~Server()
-00048 {
-00049 }
-00050 
-00051 void Server::SendOpers(string s)
-00052 {
-00053         WriteOpers("%s",s.c_str());
-00054 }
-00055 
-00056 void Server::Log(int level, string s)
-00057 {
-00058         log(level,"%s",s.c_str());
-00059 }
-00060 
-00061 void Server::Send(int Socket, string s)
-00062 {
-00063         Write(Socket,"%s",s.c_str());
-00064 }
-00065 
-00066 void Server::SendServ(int Socket, string s)
-00067 {
-00068         WriteServ(Socket,"%s",s.c_str());
-00069 }
-00070 
-00071 void Server::SendFrom(int Socket, userrec* User, string s)
-00072 {
-00073         WriteFrom(Socket,User,"%s",s.c_str());
+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 void Server::SendTo(userrec* Source, userrec* Dest, string s)
-00077 {
-00078         WriteTo(Source,Dest,"%s",s.c_str());
-00079 }
-00080 
-00081 void Server::SendChannel(userrec* User, chanrec* Channel, string s,bool IncludeSender)
-00082 {
-00083         if (IncludeSender)
-00084         {
-00085                 WriteChannel(Channel,User,"%s",s.c_str());
-00086         }
-00087         else
-00088         {
-00089                 ChanExceptSender(Channel,User,"%s",s.c_str());
-00090         }
-00091 }
-00092 
-00093 bool Server::CommonChannels(userrec* u1, userrec* u2)
-00094 {
-00095         return (common_channels(u1,u2) != 0);
-00096 }
-00097 
-00098 void Server::SendCommon(userrec* User, string text,bool IncludeSender)
-00099 {
-00100         if (IncludeSender)
-00101         {
-00102                 WriteCommon(User,"%s",text.c_str());
-00103         }
-00104         else
-00105         {
-00106                 WriteCommonExcept(User,"%s",text.c_str());
-00107         }
-00108 }
-00109 
-00110 void Server::SendWallops(userrec* User, string text)
-00111 {
-00112         WriteWallOps(User,"%s",text.c_str());
-00113 }
-00114 
-00115 bool Server::IsNick(string nick)
-00116 {
-00117         return (isnick(nick.c_str()) != 0);
-00118 }
-00119 
-00120 userrec* Server::FindNick(string nick)
-00121 {
-00122         return Find(nick);
-00123 }
-00124 
-00125 chanrec* Server::FindChannel(string channel)
-00126 {
-00127         return FindChan(channel.c_str());
-00128 }
-00129 
-00130 string Server::ChanMode(userrec* User, chanrec* Chan)
-00131 {
-00132         string mode = cmode(User,Chan);
-00133         return mode;
-00134 }
-00135 
-00136 string Server::GetServerName()
-00137 {
-00138         return getservername();
-00139 }
-00140 
-00141 string Server::GetNetworkName()
-00142 {
-00143         return getnetworkname();
-00144 }
-00145 
-00146 Admin Server::GetAdmin()
-00147 {
-00148         return Admin(getadminname(),getadminemail(),getadminnick());
-00149 }
-00150 
+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) { return false; }
+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 ConfigReader::ConfigReader()
+00152 void Server::SendToModeMask(std::string modes, int flags, std::string text)
 00153 {
-00154         fname = CONFIG_FILE;
+00154         WriteMode(modes.c_str(),flags,"%s",text.c_str());
 00155 }
 00156 
-00157 
-00158 ConfigReader::~ConfigReader()
-00159 {
+00157 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
+00158 {
+00159         return add_channel(user,cname.c_str(),key.c_str(),true);
 00160 }
 00161 
-00162 
-00163 ConfigReader::ConfigReader(string filename) : fname(filename) { };
-00164 
-00165 string ConfigReader::ReadValue(string tag, string name, int index)
-00166 {
-00167         char val[MAXBUF];
-00168         ReadConf(fname.c_str(),tag.c_str(),name.c_str(),index,val);
-00169         string s = val;
-00170         return s;
-00171 }
-00172 
-00173 
-00174 int ConfigReader::Enumerate(string tag)
-00175 {
-00176         return EnumConf(fname.c_str(),tag.c_str());
-00177 }
-00178 
-00179 
-00180 bool ConfigReader::Verify()
-00181 {
-00182         return true;
-00183 }
-00184 
-00185 
-00186 FileReader::FileReader(string filename)
-00187 {
-00188         file_cache c;
-00189         readfile(c,filename.c_str());
-00190         this->fc = c;
+00162 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
+00163 {
+00164         return del_channel(user,cname.c_str(),reason.c_str(),false);
+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         send_network_quit(user->nick,reason.c_str());
+00175         kill_link(user,reason.c_str());
+00176 }
+00177 
+00178 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+00179 {
+00180         call_handler(commandname.c_str(),parameters,pcnt,user);
+00181 }
+00182 
+00183 void Server::Log(int level, std::string s)
+00184 {
+00185         log(level,"%s",s.c_str());
+00186 }
+00187 
+00188 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
+00189 {
+00190         createcommand(cmd,f,flags,minparams);
 00191 }
 00192 
-00193 FileReader::FileReader()
+00193 void Server::SendMode(char **parameters, int pcnt, userrec *user)
 00194 {
-00195 }
-00196 
-00197 void FileReader::LoadFile(string filename)
-00198 {
-00199         file_cache c;
-00200         readfile(c,filename.c_str());
-00201         this->fc = c;
-00202 }
-00203 
-00204 FileReader::~FileReader()
-00205 {
+00195         server_mode(parameters,pcnt,user);
+00196 }
+00197 
+00198 void Server::Send(int Socket, std::string s)
+00199 {
+00200         Write(Socket,"%s",s.c_str());
+00201 }
+00202 
+00203 void Server::SendServ(int Socket, std::string s)
+00204 {
+00205         WriteServ(Socket,"%s",s.c_str());
 00206 }
 00207 
-00208 string FileReader::GetLine(int x)
+00208 void Server::SendFrom(int Socket, userrec* User, std::string s)
 00209 {
-00210         if ((x<0) || (x>fc.size()))
-00211                 return "";
-00212         return fc[x];
-00213 }
-00214 
-00215 int FileReader::FileSize()
-00216 {
-00217         return fc.size();
-00218 }
-00219 
-00220 
-00221 vector<Module*> modules(255);
-00222 vector<ircd_module*> factory(255);
-00223 
-00224 int MODCOUNT  = -1;
-00225 
+00210         WriteFrom(Socket,User,"%s",s.c_str());
+00211 }
+00212 
+00213 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
+00214 {
+00215         if (!Source)
+00216         {
+00217                 // if source is NULL, then the message originates from the local server
+00218                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+00219         }
+00220         else
+00221         {
+00222                 // otherwise it comes from the user specified
+00223                 WriteTo(Source,Dest,"%s",s.c_str());
+00224         }
+00225 }
 00226 
-