From 877a15fc3db18be9131c886720516eae6f582886 Mon Sep 17 00:00:00 2001 From: brain Date: Sat, 1 May 2004 16:54:50 +0000 Subject: Added extra docs to cover OnUserSync etc git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@769 e03df62e-2008-0410-955e-edbf42e46eb7 --- docs/module-doc/modules_8cpp-source.html | 1082 +++++++++++++++++------------- 1 file changed, 625 insertions(+), 457 deletions(-) (limited to 'docs/module-doc/modules_8cpp-source.html') diff --git a/docs/module-doc/modules_8cpp-source.html b/docs/module-doc/modules_8cpp-source.html index 7d63ff9d7..5d6a33b5e 100644 --- a/docs/module-doc/modules_8cpp-source.html +++ b/docs/module-doc/modules_8cpp-source.html @@ -6,493 +6,661 @@
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 #include "mode.h"
-00016 #include "message.h"
-00017 #include "commands.h"
-00018 
-00019 // class type for holding an extended mode character - internal to core
-00020 
-00021 class ExtMode : public classbase
-00022 {
-00023 public:
-00024         char modechar;
-00025         int type;
-00026         int params_when_on;
-00027         int params_when_off;
-00028         bool needsoper;
-00029         bool list;
-00030         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) { };
-00031 };                                     
-00032 
-00033 typedef std::vector<ExtMode> ExtModeList;
-00034 typedef ExtModeList::iterator ExtModeListIter;
-00035 
-00036 ExtModeList EMode;
-00037 
-00038 // returns true if an extended mode character is in use
-00039 bool ModeDefined(char modechar, int type)
-00040 {
-00041         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00042         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00043         {
-00044                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00045                 if ((i->modechar == modechar) && (i->type == type))
-00046                 {
-00047                         return true;
-00048                 }
-00049         }
-00050         return false;
-00051 }
-00052 
-00053 bool ModeIsListMode(char modechar, int type)
-00054 {
-00055         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00056         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00057         {
-00058                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00059                 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
-00060                 {
-00061                         return true;
-00062                 }
-00063         }
-00064         return false;
-00065 }
-00066 
-00067 bool ModeDefinedOper(char modechar, int type)
-00068 {
-00069         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00070         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00071         {
-00072                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00073                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
-00074                 {
-00075                         return true;
-00076                 }
-00077         }
-00078         return false;
-00079 }
-00080 
-00081 // returns number of parameters for a custom mode when it is switched on
-00082 int ModeDefinedOn(char modechar, int type)
-00083 {
-00084         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00085         {
-00086                 if ((i->modechar == modechar) && (i->type == type))
-00087                 {
-00088                         return i->params_when_on;
-00089                 }
-00090         }
-00091         return 0;
-00092 }
-00093 
-00094 // returns number of parameters for a custom mode when it is switched on
-00095 int ModeDefinedOff(char modechar, int type)
-00096 {
-00097         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00098         {
-00099                 if ((i->modechar == modechar) && (i->type == type))
-00100                 {
-00101                         return i->params_when_off;
+
modules.cpp
Go to the documentation of this file.
00001 #include "inspircd.h"
+00002 #include "inspircd_io.h"
+00003 #include "inspircd_util.h"
+00004 #include "inspircd_config.h"
+00005 #include <unistd.h>
+00006 #include <fcntl.h>
+00007 #include <sys/errno.h>
+00008 #include <sys/ioctl.h>
+00009 #include <sys/utsname.h>
+00010 #include <cstdio>
+00011 #include <time.h>
+00012 #include <string>
+00013 #ifdef GCC3
+00014 #include <ext/hash_map>
+00015 #else
+00016 #include <hash_map>
+00017 #endif
+00018 #include <map>
+00019 #include <sstream>
+00020 #include <vector>
+00021 #include <errno.h>
+00022 #include <deque>
+00023 #include <errno.h>
+00024 #include <unistd.h>
+00025 #include <sched.h>
+00026 #include "connection.h"
+00027 #include "users.h"
+00028 #include "servers.h"
+00029 #include "ctables.h"
+00030 #include "globals.h"
+00031 #include "modules.h"
+00032 #include "dynamic.h"
+00033 #include "wildcard.h"
+00034 #include "message.h"
+00035 #include "mode.h"
+00036 #include "xline.h"
+00037 #include "commands.h"
+00038 
+00039 #ifdef GCC3
+00040 #define nspace __gnu_cxx
+00041 #else
+00042 #define nspace std
+00043 #endif
+00044 
+00045 using namespace std;
+00046 
+00047 extern int MODCOUNT;
+00048 extern vector<Module*> modules;
+00049 extern vector<ircd_module*> factory;
+00050 
+00051 extern int LogLevel;
+00052 extern char ServerName[MAXBUF];
+00053 extern char Network[MAXBUF];
+00054 extern char ServerDesc[MAXBUF];
+00055 extern char AdminName[MAXBUF];
+00056 extern char AdminEmail[MAXBUF];
+00057 extern char AdminNick[MAXBUF];
+00058 extern char diepass[MAXBUF];
+00059 extern char restartpass[MAXBUF];
+00060 extern char motd[MAXBUF];
+00061 extern char rules[MAXBUF];
+00062 extern char list[MAXBUF];
+00063 extern char PrefixQuit[MAXBUF];
+00064 extern char DieValue[MAXBUF];
+00065 
+00066 extern int debugging;
+00067 extern int WHOWAS_STALE;
+00068 extern int WHOWAS_MAX;
+00069 extern int DieDelay;
+00070 extern time_t startup_time;
+00071 extern int NetBufferSize;
+00072 extern int MaxWhoResults;
+00073 extern time_t nb_start;
+00074 
+00075 extern std::vector<int> fd_reap;
+00076 extern std::vector<std::string> module_names;
+00077 
+00078 extern char bannerBuffer[MAXBUF];
+00079 extern int boundPortCount;
+00080 extern int portCount;
+00081 extern int UDPportCount;
+00082 extern int ports[MAXSOCKS];
+00083 extern int defaultRoute;
+00084 
+00085 extern std::vector<long> auth_cookies;
+00086 extern std::stringstream config_f;
+00087 
+00088 extern serverrec* me[32];
+00089 
+00090 extern FILE *log_file;
+00091 
+00092 
+00093 namespace nspace
+00094 {
+00095         template<> struct nspace::hash<in_addr>
+00096         {
+00097                 size_t operator()(const struct in_addr &a) const
+00098                 {
+00099                         size_t q;
+00100                         memcpy(&q,&a,sizeof(size_t));
+00101                         return q;
 00102                 }
-00103         }
-00104         return 0;
-00105 }
-00106 
-00107 // returns true if an extended mode character is in use
-00108 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
-00109 {
-00110         if (ModeDefined(modechar,type)) {
-00111                 return false;
-00112         }
-00113         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
-00114         return true;
-00115 }
-00116 
-00117 // turns a mode into a listmode
-00118 void ModeMakeList(char modechar)
-00119 {
-00120         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00121         {
-00122                 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
-00123                 {
-00124                         i->list = true;
-00125                         return;
-00126                 }
-00127         }
-00128         return;
-00129 }
-00130 
-00131 // version is a simple class for holding a modules version number
-00132 
-00133 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+00103         };
+00104 
+00105         template<> struct nspace::hash<string>
+00106         {
+00107                 size_t operator()(const string &s) const
+00108                 {
+00109                         char a[MAXBUF];
+00110                         static struct hash<const char *> strhash;
+00111                         strcpy(a,s.c_str());
+00112                         strlower(a);
+00113                         return strhash(a);
+00114                 }
+00115         };
+00116 }       
+00117 
+00118 
+00119 struct StrHashComp
+00120 {
+00121 
+00122         bool operator()(const string& s1, const string& s2) const
+00123         {
+00124                 char a[MAXBUF],b[MAXBUF];
+00125                 strcpy(a,s1.c_str());
+00126                 strcpy(b,s2.c_str());
+00127                 return (strcasecmp(a,b) == 0);
+00128         }
+00129 
+00130 };
+00131 
+00132 struct InAddr_HashComp
+00133 {
 00134 
-00135 // admin is a simple class for holding a server's administrative info
-00136 
-00137 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
-00138 
-00139 Module::Module() { }
-00140 Module::~Module() { }
-00141 void Module::OnUserConnect(userrec* user) { }
-00142 void Module::OnUserQuit(userrec* user) { }
-00143 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-00144 void Module::OnUserPart(userrec* user, chanrec* channel) { }
-00145 void Module::OnPacketTransmit(char *p) { }
-00146 void Module::OnPacketReceive(char *p) { }
-00147 void Module::OnRehash() { }
-00148 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
-00149 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
-00150 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { return false; }
-00151 Version Module::GetVersion() { return Version(1,0,0,0); }
-00152 void Module::OnOper(userrec* user) { };
-00153 void Module::OnInfo(userrec* user) { };
-00154 void Module::OnWhois(userrec* source, userrec* dest) { };
-00155 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; };
-00156 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; };
-00157 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
-00158 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
-00159 
-00160 // server is a wrapper class that provides methods to all of the C-style
-00161 // exports in the core
-00162 //
+00135         bool operator()(const in_addr &s1, const in_addr &s2) const
+00136         {
+00137                 size_t q;
+00138                 size_t p;
+00139                 
+00140                 memcpy(&q,&s1,sizeof(size_t));
+00141                 memcpy(&p,&s2,sizeof(size_t));
+00142                 
+00143                 return (q == p);
+00144         }
+00145 
+00146 };
+00147 
+00148 
+00149 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
+00150 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
+00151 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
+00152 typedef std::deque<command_t> command_table;
+00153 
+00154 
+00155 extern user_hash clientlist;
+00156 extern chan_hash chanlist;
+00157 extern user_hash whowas;
+00158 extern command_table cmdlist;
+00159 extern file_cache MOTD;
+00160 extern file_cache RULES;
+00161 extern address_cache IP;
+00162 
 00163 
-00164 Server::Server()
-00165 {
-00166 }
-00167 
-00168 Server::~Server()
-00169 {
-00170 }
-00171 
-00172 void Server::SendOpers(std::string s)
-00173 {
-00174         WriteOpers("%s",s.c_str());
-00175 }
-00176 
-00177 bool Server::MatchText(std::string sliteral, std::string spattern)
-00178 {
-00179         char literal[MAXBUF],pattern[MAXBUF];
-00180         strncpy(literal,sliteral.c_str(),MAXBUF);
-00181         strncpy(pattern,spattern.c_str(),MAXBUF);
-00182         return match(literal,pattern);
-00183 }
-00184 
-00185 void Server::SendToModeMask(std::string modes, int flags, std::string text)
+00164 // class type for holding an extended mode character - internal to core
+00165 
+00166 class ExtMode : public classbase
+00167 {
+00168 public:
+00169         char modechar;
+00170         int type;
+00171         int params_when_on;
+00172         int params_when_off;
+00173         bool needsoper;
+00174         bool list;
+00175         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) { };
+00176 };                                     
+00177 
+00178 typedef std::vector<ExtMode> ExtModeList;
+00179 typedef ExtModeList::iterator ExtModeListIter;
+00180 
+00181 
+00182 ExtModeList EMode;
+00183 
+00184 // returns true if an extended mode character is in use
+00185 bool ModeDefined(char modechar, int type)
 00186 {
-00187         WriteMode(modes.c_str(),flags,"%s",text.c_str());
-00188 }
-00189 
-00190 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
-00191 {
-00192         return add_channel(user,cname.c_str(),key.c_str(),true);
-00193 }
-00194 
-00195 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
-00196 {
-00197         return del_channel(user,cname.c_str(),reason.c_str(),false);
-00198 }
-00199 
-00200 void Server::ChangeUserNick(userrec* user, std::string nickname)
-00201 {
-00202         force_nickchange(user,nickname.c_str());
-00203 }
-00204 
-00205 void Server::QuitUser(userrec* user, std::string reason)
-00206 {
-00207         send_network_quit(user->nick,reason.c_str());
-00208         kill_link(user,reason.c_str());
-00209 }
-00210 
-00211 bool Server::IsUlined(std::string server)
-00212 {
-00213         return is_uline(server.c_str());
-00214 }
-00215 
-00216 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
-00217 {
-00218         call_handler(commandname.c_str(),parameters,pcnt,user);
-00219 }
-00220 
-00221 void Server::Log(int level, std::string s)
-00222 {
-00223         log(level,"%s",s.c_str());
-00224 }
-00225 
-00226 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
-00227 {
-00228         createcommand(cmd,f,flags,minparams);
-00229 }
-00230 
-00231 void Server::SendMode(char **parameters, int pcnt, userrec *user)
-00232 {
-00233         server_mode(parameters,pcnt,user);
-00234 }
-00235 
-00236 void Server::Send(int Socket, std::string s)
-00237 {
-00238         Write(Socket,"%s",s.c_str());
-00239 }
-00240 
-00241 void Server::SendServ(int Socket, std::string s)
+00187         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
+00188         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00189         {
+00190                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
+00191                 if ((i->modechar == modechar) && (i->type == type))
+00192                 {
+00193                         return true;
+00194                 }
+00195         }
+00196         return false;
+00197 }
+00198 
+00199 bool ModeIsListMode(char modechar, int type)
+00200 {
+00201         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
+00202         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00203         {
+00204                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
+00205                 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
+00206                 {
+00207                         return true;
+00208                 }
+00209         }
+00210         return false;
+00211 }
+00212 
+00213 bool ModeDefinedOper(char modechar, int type)
+00214 {
+00215         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
+00216         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00217         {
+00218                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
+00219                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
+00220                 {
+00221                         return true;
+00222                 }
+00223         }
+00224         return false;
+00225 }
+00226 
+00227 // returns number of parameters for a custom mode when it is switched on
+00228 int ModeDefinedOn(char modechar, int type)
+00229 {
+00230         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00231         {
+00232                 if ((i->modechar == modechar) && (i->type == type))
+00233                 {
+00234                         return i->params_when_on;
+00235                 }
+00236         }
+00237         return 0;
+00238 }
+00239 
+00240 // returns number of parameters for a custom mode when it is switched on
+00241 int ModeDefinedOff(char modechar, int type)
 00242 {
-00243         WriteServ(Socket,"%s",s.c_str());
-00244 }
-00245 
-00246 void Server::SendFrom(int Socket, userrec* User, std::string s)
-00247 {
-00248         WriteFrom(Socket,User,"%s",s.c_str());
-00249 }
-00250 
-00251 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
-00252 {
-00253         if (!Source)
-00254         {
-00255                 // if source is NULL, then the message originates from the local server
-00256                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
-00257         }
-00258         else
-00259         {
-00260                 // otherwise it comes from the user specified
-00261                 WriteTo(Source,Dest,"%s",s.c_str());
-00262         }
-00263 }
-00264 
-00265 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
-00266 {
-00267         if (IncludeSender)
-00268         {
-00269                 WriteChannel(Channel,User,"%s",s.c_str());
-00270         }
-00271         else
-00272         {
-00273                 ChanExceptSender(Channel,User,"%s",s.c_str());
-00274         }
+00243         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00244         {
+00245                 if ((i->modechar == modechar) && (i->type == type))
+00246                 {
+00247                         return i->params_when_off;
+00248                 }
+00249         }
+00250         return 0;
+00251 }
+00252 
+00253 // returns true if an extended mode character is in use
+00254 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
+00255 {
+00256         if (ModeDefined(modechar,type)) {
+00257                 return false;
+00258         }
+00259         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
+00260         return true;
+00261 }
+00262 
+00263 // turns a mode into a listmode
+00264 void ModeMakeList(char modechar)
+00265 {
+00266         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00267         {
+00268                 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
+00269                 {
+00270                         i->list = true;
+00271                         return;
+00272                 }
+00273         }
+00274         return;
 00275 }
 00276 
-00277 bool Server::CommonChannels(userrec* u1, userrec* u2)
-00278 {
-00279         return (common_channels(u1,u2) != 0);
-00280 }
-00281 
-00282 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
-00283 {
-00284         if (IncludeSender)
-00285         {
-00286                 WriteCommon(User,"%s",text.c_str());
-00287         }
-00288         else
-00289         {
-00290                 WriteCommonExcept(User,"%s",text.c_str());
-00291         }
-00292 }
-00293 
-00294 void Server::SendWallops(userrec* User, std::string text)
-00295 {
-00296         WriteWallOps(User,false,"%s",text.c_str());
-00297 }
-00298 
-00299 void Server::ChangeHost(userrec* user, std::string host)
-00300 {
-00301         ChangeDisplayedHost(user,host.c_str());
-00302 }
-00303 
-00304 void Server::ChangeGECOS(userrec* user, std::string gecos)
-00305 {
-00306         ChangeName(user,gecos.c_str());
-00307 }
+00277 // version is a simple class for holding a modules version number
+00278 
+00279 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+00280 
+00281 // admin is a simple class for holding a server's administrative info
+00282 
+00283 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
+00284 
+00285 Module::Module() { }
+00286 Module::~Module() { }
+00287 void Module::OnUserConnect(userrec* user) { }
+00288 void Module::OnUserQuit(userrec* user) { }
+00289 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
+00290 void Module::OnUserPart(userrec* user, chanrec* channel) { }
+00291 void Module::OnPacketTransmit(char *p) { }
+00292 void Module::OnPacketReceive(char *p) { }
+00293 void Module::OnRehash() { }
+00294 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
+00295 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
+00296 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { return false; }
+00297 Version Module::GetVersion() { return Version(1,0,0,0); }
+00298 void Module::OnOper(userrec* user) { };
+00299 void Module::OnInfo(userrec* user) { };
+00300 void Module::OnWhois(userrec* source, userrec* dest) { };
+00301 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; };
+00302 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; };
+00303 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
+00304 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
+00305 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
+00306 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
+00307 
 00308 
-00309 bool Server::IsNick(std::string nick)
-00310 {
-00311         return (isnick(nick.c_str()) != 0);
-00312 }
-00313 
-00314 userrec* Server::FindNick(std::string nick)
-00315 {
-00316         return Find(nick);
-00317 }
-00318 
-00319 chanrec* Server::FindChannel(std::string channel)
-00320 {
-00321         return FindChan(channel.c_str());
-00322 }
-00323 
-00324 std::string Server::ChanMode(userrec* User, chanrec* Chan)
-00325 {
-00326         return cmode(User,Chan);
-00327 }
-00328 
-00329 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
-00330 {
-00331         return has_channel(User,Chan);
+00309 // server is a wrapper class that provides methods to all of the C-style
+00310 // exports in the core
+00311 //
+00312 
+00313 Server::Server()
+00314 {
+00315 }
+00316 
+00317 Server::~Server()
+00318 {
+00319 }
+00320 
+00321 void Server::SendOpers(std::string s)
+00322 {
+00323         WriteOpers("%s",s.c_str());
+00324 }
+00325 
+00326 bool Server::MatchText(std::string sliteral, std::string spattern)
+00327 {
+00328         char literal[MAXBUF],pattern[MAXBUF];
+00329         strncpy(literal,sliteral.c_str(),MAXBUF);
+00330         strncpy(pattern,spattern.c_str(),MAXBUF);
+00331         return match(literal,pattern);
 00332 }
 00333 
-00334 std::string Server::GetServerName()
+00334 void Server::SendToModeMask(std::string modes, int flags, std::string text)
 00335 {
-00336         return getservername();
+00336         WriteMode(modes.c_str(),flags,"%s",text.c_str());
 00337 }
 00338 
-00339 std::string Server::GetNetworkName()
+00339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
 00340 {
-00341         return getnetworkname();
+00341         return add_channel(user,cname.c_str(),key.c_str(),true);
 00342 }
 00343 
-00344 Admin Server::GetAdmin()
+00344 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
 00345 {
-00346         return Admin(getadminname(),getadminemail(),getadminnick());
+00346         return del_channel(user,cname.c_str(),reason.c_str(),false);
 00347 }
 00348 
-00349 
-00350 
-00351 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
-00352 {
-00353         if (type == MT_SERVER)
+00349 chanuserlist Server::GetUsers(chanrec* chan)
+00350 {
+00351         chanuserlist userl;
+00352         userl.clear();
+00353         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 00354         {
-00355                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
-00356                 return false;
-00357         }
-00358         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
-00359         {
-00360                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
-00361                 return false;
-00362         }
-00363         if ((params_when_on>1) || (params_when_off>1))
-00364         {
-00365                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
-00366                 return false;
-00367         }
-00368         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
-00369 }
-00370 
-00371 bool Server::AddExtendedListMode(char modechar)
-00372 {
-00373         bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
-00374         if (res)
-00375                 ModeMakeList(modechar);
-00376         return res;
+00355                 if (i->second)
+00356                 {
+00357                         if (has_channel(i->second,chan))
+00358                         {
+00359                                 if (isnick(i->second->nick))
+00360                                 {
+00361                                         userl.push_back(i->second);
+00362                                 }
+00363                         }
+00364                 }
+00365         }
+00366         return userl;
+00367 }
+00368 void Server::ChangeUserNick(userrec* user, std::string nickname)
+00369 {
+00370         force_nickchange(user,nickname.c_str());
+00371 }
+00372 
+00373 void Server::QuitUser(userrec* user, std::string reason)
+00374 {
+00375         send_network_quit(user->nick,reason.c_str());
+00376         kill_link(user,reason.c_str());
 00377 }
 00378 
-00379 int Server::CountUsers(chanrec* c)
+00379 bool Server::IsUlined(std::string server)
 00380 {
-00381         return usercount(c);
+00381         return is_uline(server.c_str());
 00382 }
 00383 
-00384 
-00385 ConfigReader::ConfigReader()
-00386 {
-00387         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00388         this->error = LoadConf(CONFIG_FILE,this->cache);
-00389 }
-00390 
-00391 
-00392 ConfigReader::~ConfigReader()
-00393 {
-00394         if (this->cache)
-00395                 delete this->cache;
-00396 }
-00397 
+00384 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+00385 {
+00386         call_handler(commandname.c_str(),parameters,pcnt,user);
+00387 }
+00388 
+00389 void Server::Log(int level, std::string s)
+00390 {
+00391         log(level,"%s",s.c_str());
+00392 }
+00393 
+00394 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
+00395 {
+00396         createcommand(cmd,f,flags,minparams);
+00397 }
 00398 
-00399 ConfigReader::ConfigReader(std::string filename)
+00399 void Server::SendMode(char **parameters, int pcnt, userrec *user)
 00400 {
-00401         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00402         this->error = LoadConf(filename.c_str(),this->cache);
-00403 };
-00404 
-00405 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
-00406 {
-00407         char val[MAXBUF];
-00408         char t[MAXBUF];
-00409         char n[MAXBUF];
-00410         strncpy(t,tag.c_str(),MAXBUF);
-00411         strncpy(n,name.c_str(),MAXBUF);
-00412         ReadConf(cache,t,n,index,val);
-00413         return std::string(val);
-00414 }
-00415 
-00416 
-00417 int ConfigReader::Enumerate(std::string tag)
-00418 {
-00419         return EnumConf(cache,tag.c_str());
-00420 }
-00421 
-00422 int ConfigReader::EnumerateValues(std::string tag, int index)
-00423 {
-00424         return EnumValues(cache, tag.c_str(), index);
-00425 }
-00426 
-00427 bool ConfigReader::Verify()
-00428 {
-00429         return this->error;
-00430 }
-00431 
+00401         server_mode(parameters,pcnt,user);
+00402 }
+00403 
+00404 void Server::Send(int Socket, std::string s)
+00405 {
+00406         Write(Socket,"%s",s.c_str());
+00407 }
+00408 
+00409 void Server::SendServ(int Socket, std::string s)
+00410 {
+00411         WriteServ(Socket,"%s",s.c_str());
+00412 }
+00413 
+00414 void Server::SendFrom(int Socket, userrec* User, std::string s)
+00415 {
+00416         WriteFrom(Socket,User,"%s",s.c_str());
+00417 }
+00418 
+00419 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
+00420 {
+00421         if (!Source)
+00422         {
+00423                 // if source is NULL, then the message originates from the local server
+00424                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+00425         }
+00426         else
+00427         {
+00428                 // otherwise it comes from the user specified
+00429                 WriteTo(Source,Dest,"%s",s.c_str());
+00430         }
+00431 }
 00432 
-00433 FileReader::FileReader(std::string filename)
+00433 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
 00434 {
-00435         file_cache c;
-00436         readfile(c,filename.c_str());
-00437         this->fc = c;
-00438 }
-00439 
-00440 FileReader::FileReader()
-00441 {
-00442 }
-00443 
-00444 void FileReader::LoadFile(std::string filename)
-00445 {
-00446         file_cache c;
-00447         readfile(c,filename.c_str());
-00448         this->fc = c;
-00449 }
-00450 
-00451 
-00452 FileReader::~FileReader()
-00453 {
-00454 }
-00455 
-00456 bool FileReader::Exists()
-00457 {
-00458         if (fc.size() == 0)
-00459         {
-00460                 return(false);
-00461         }
-00462         else
-00463         {
-00464                 return(true);
-00465         }
-00466 }
-00467 
-00468 std::string FileReader::GetLine(int x)
-00469 {
-00470         if ((x<0) || (x>fc.size()))
-00471                 return "";
-00472         return fc[x];
-00473 }
-00474 
-00475 int FileReader::FileSize()
-00476 {
-00477         return fc.size();
-00478 }
-00479 
-00480 
-00481 std::vector<Module*> modules(255);
-00482 std::vector<ircd_module*> factory(255);
-00483 
-00484 int MODCOUNT  = -1;
-00485 
+00435         if (IncludeSender)
+00436         {
+00437                 WriteChannel(Channel,User,"%s",s.c_str());
+00438         }
+00439         else
+00440         {
+00441                 ChanExceptSender(Channel,User,"%s",s.c_str());
+00442         }
+00443 }
+00444 
+00445 bool Server::CommonChannels(userrec* u1, userrec* u2)
+00446 {
+00447         return (common_channels(u1,u2) != 0);
+00448 }
+00449 
+00450 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
+00451 {
+00452         if (IncludeSender)
+00453         {
+00454                 WriteCommon(User,"%s",text.c_str());
+00455         }
+00456         else
+00457         {
+00458                 WriteCommonExcept(User,"%s",text.c_str());
+00459         }
+00460 }
+00461 
+00462 void Server::SendWallops(userrec* User, std::string text)
+00463 {
+00464         WriteWallOps(User,false,"%s",text.c_str());
+00465 }
+00466 
+00467 void Server::ChangeHost(userrec* user, std::string host)
+00468 {
+00469         ChangeDisplayedHost(user,host.c_str());
+00470 }
+00471 
+00472 void Server::ChangeGECOS(userrec* user, std::string gecos)
+00473 {
+00474         ChangeName(user,gecos.c_str());
+00475 }
+00476 
+00477 bool Server::IsNick(std::string nick)
+00478 {
+00479         return (isnick(nick.c_str()) != 0);
+00480 }
+00481 
+00482 userrec* Server::FindNick(std::string nick)
+00483 {
+00484         return Find(nick);
+00485 }
 00486 
-
Generated on Sat May 1 13:39:00 2004 for InspIRCd by
+00487 chanrec* Server::FindChannel(std::string channel)
+00488 {
+00489         return FindChan(channel.c_str());
+00490 }
+00491 
+00492 std::string Server::ChanMode(userrec* User, chanrec* Chan)
+00493 {
+00494         return cmode(User,Chan);
+00495 }
+00496 
+00497 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
+00498 {
+00499         return has_channel(User,Chan);
+00500 }
+00501 
+00502 std::string Server::GetServerName()
+00503 {
+00504         return getservername();
+00505 }
+00506 
+00507 std::string Server::GetNetworkName()
+00508 {
+00509         return getnetworkname();
+00510 }
+00511 
+00512 Admin Server::GetAdmin()
+00513 {
+00514         return Admin(getadminname(),getadminemail(),getadminnick());
+00515 }
+00516 
+00517 
+00518 
+00519 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
+00520 {
+00521         if (type == MT_SERVER)
+00522         {
+00523                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
+00524                 return false;
+00525         }
+00526         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
+00527         {
+00528                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
+00529                 return false;
+00530         }
+00531         if ((params_when_on>1) || (params_when_off>1))
+00532         {
+00533                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
+00534                 return false;
+00535         }
+00536         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
+00537 }
+00538 
+00539 bool Server::AddExtendedListMode(char modechar)
+00540 {
+00541         bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
+00542         if (res)
+00543                 ModeMakeList(modechar);
+00544         return res;
+00545 }
+00546 
+00547 int Server::CountUsers(chanrec* c)
+00548 {
+00549         return usercount(c);
+00550 }
+00551 
+00552 
+00553 ConfigReader::ConfigReader()
+00554 {
+00555         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00556         this->error = LoadConf(CONFIG_FILE,this->cache);
+00557 }
+00558 
+00559 
+00560 ConfigReader::~ConfigReader()
+00561 {
+00562         if (this->cache)
+00563                 delete this->cache;
+00564 }
+00565 
+00566 
+00567 ConfigReader::ConfigReader(std::string filename)
+00568 {
+00569         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00570         this->error = LoadConf(filename.c_str(),this->cache);
+00571 };
+00572 
+00573 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
+00574 {
+00575         char val[MAXBUF];
+00576         char t[MAXBUF];
+00577         char n[MAXBUF];
+00578         strncpy(t,tag.c_str(),MAXBUF);
+00579         strncpy(n,name.c_str(),MAXBUF);
+00580         ReadConf(cache,t,n,index,val);
+00581         return std::string(val);
+00582 }
+00583 
+00584 
+00585 int ConfigReader::Enumerate(std::string tag)
+00586 {
+00587         return EnumConf(cache,tag.c_str());
+00588 }
+00589 
+00590 int ConfigReader::EnumerateValues(std::string tag, int index)
+00591 {
+00592         return EnumValues(cache, tag.c_str(), index);
+00593 }
+00594 
+00595 bool ConfigReader::Verify()
+00596 {
+00597         return this->error;
+00598 }
+00599 
+00600 
+00601 FileReader::FileReader(std::string filename)
+00602 {
+00603         file_cache c;
+00604         readfile(c,filename.c_str());
+00605         this->fc = c;
+00606 }
+00607 
+00608 FileReader::FileReader()
+00609 {
+00610 }
+00611 
+00612 void FileReader::LoadFile(std::string filename)
+00613 {
+00614         file_cache c;
+00615         readfile(c,filename.c_str());
+00616         this->fc = c;
+00617 }
+00618 
+00619 
+00620 FileReader::~FileReader()
+00621 {
+00622 }
+00623 
+00624 bool FileReader::Exists()
+00625 {
+00626         if (fc.size() == 0)
+00627         {
+00628                 return(false);
+00629         }
+00630         else
+00631         {
+00632                 return(true);
+00633         }
+00634 }
+00635 
+00636 std::string FileReader::GetLine(int x)
+00637 {
+00638         if ((x<0) || (x>fc.size()))
+00639                 return "";
+00640         return fc[x];
+00641 }
+00642 
+00643 int FileReader::FileSize()
+00644 {
+00645         return fc.size();
+00646 }
+00647 
+00648 
+00649 std::vector<Module*> modules(255);
+00650 std::vector<ircd_module*> factory(255);
+00651 
+00652 int MODCOUNT  = -1;
+00653 
+00654 
+
Generated on Sat May 1 17:50:06 2004 for InspIRCd by doxygen1.3-rc3
-- cgit v1.2.3