From 71bedf497cde8b0b38afbb366828b3df9c2803d6 Mon Sep 17 00:00:00 2001
From: brain
Date: Mon, 19 Dec 2005 18:04:22 +0000
Subject: git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@2578
e03df62e-2008-0410-955e-edbf42e46eb7
---
docs/module-doc/modules_8cpp-source.html | 1799 +++++++++++++++---------------
1 file changed, 899 insertions(+), 900 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 a13d4ac10..ac2ff009e 100644
--- a/docs/module-doc/modules_8cpp-source.html
+++ b/docs/module-doc/modules_8cpp-source.html
@@ -28,923 +28,922 @@
00019 #include "inspircd_config.h"
00020 #include "inspircd.h"
00021 #include "inspircd_io.h"
-00022 #include "inspircd_util.h"
-00023 #include <unistd.h>
-00024 #include <sys/errno.h>
-00025 #include <time.h>
-00026 #include <string>
-00027 #ifdef GCC3
-00028 #include <ext/hash_map>
-00029 #else
-00030 #include <hash_map>
-00031 #endif
-00032 #include <map>
-00033 #include <sstream>
-00034 #include <vector>
-00035 #include <deque>
-00036 #include "users.h"
-00037 #include "ctables.h"
-00038 #include "globals.h"
-00039 #include "modules.h"
-00040 #include "dynamic.h"
-00041 #include "wildcard.h"
-00042 #include "message.h"
-00043 #include "mode.h"
-00044 #include "xline.h"
-00045 #include "commands.h"
-00046 #include "inspstring.h"
-00047 #include "helperfuncs.h"
-00048 #include "hashcomp.h"
-00049 #include "socket.h"
-00050 #include "socketengine.h"
-00051 #include "typedefs.h"
-00052
-00053 extern SocketEngine* SE;
+00022 #include <unistd.h>
+00023 #include <sys/errno.h>
+00024 #include <time.h>
+00025 #include <string>
+00026 #ifdef GCC3
+00027 #include <ext/hash_map>
+00028 #else
+00029 #include <hash_map>
+00030 #endif
+00031 #include <map>
+00032 #include <sstream>
+00033 #include <vector>
+00034 #include <deque>
+00035 #include "users.h"
+00036 #include "ctables.h"
+00037 #include "globals.h"
+00038 #include "modules.h"
+00039 #include "dynamic.h"
+00040 #include "wildcard.h"
+00041 #include "message.h"
+00042 #include "mode.h"
+00043 #include "xline.h"
+00044 #include "commands.h"
+00045 #include "inspstring.h"
+00046 #include "helperfuncs.h"
+00047 #include "hashcomp.h"
+00048 #include "socket.h"
+00049 #include "socketengine.h"
+00050 #include "typedefs.h"
+00051 #include "modules.h"
+00052 #include "command_parse.h"
+00053
00054 extern ServerConfig *Config;
00055 extern InspIRCd* ServerInstance;
00056 extern int MODCOUNT;
00057 extern std::vector<Module*> modules;
00058 extern std::vector<ircd_module*> factory;
00059 extern std::vector<InspSocket*> module_sockets;
-00060
-00061 extern time_t TIME;
-00062 class Server;
-00063 extern userrec* fd_ref_table[65536];
-00064
-00065 extern user_hash clientlist;
-00066 extern chan_hash chanlist;
-00067 extern command_table cmdlist;
-00068 ExtModeList EMode;
-00069
-00070
-00071 bool ModeDefined(char modechar, int type)
-00072 {
-00073 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00074 {
-00075 if ((i->modechar == modechar) && (i->type == type))
-00076 {
-00077 return true;
-00078 }
-00079 }
-00080 return false;
-00081 }
-00082
-00083 bool ModeIsListMode(char modechar, int type)
-00084 {
-00085 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00086 {
-00087 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
-00088 {
-00089 return true;
-00090 }
-00091 }
-00092 return false;
-00093 }
-00094
-00095 bool ModeDefinedOper(char modechar, int type)
-00096 {
-00097 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00098 {
-00099 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
-00100 {
-00101 return true;
-00102 }
-00103 }
-00104 return false;
-00105 }
-00106
-00107
-00108 int ModeDefinedOn(char modechar, int type)
-00109 {
-00110 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00111 {
-00112 if ((i->modechar == modechar) && (i->type == type))
-00113 {
-00114 return i->params_when_on;
-00115 }
-00116 }
-00117 return 0;
-00118 }
-00119
-00120
-00121 int ModeDefinedOff(char modechar, int type)
-00122 {
-00123 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00124 {
-00125 if ((i->modechar == modechar) && (i->type == type))
-00126 {
-00127 return i->params_when_off;
-00128 }
-00129 }
-00130 return 0;
-00131 }
-00132
-00133
-00134 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
-00135 {
-00136 if (ModeDefined(modechar,type)) {
-00137 return false;
-00138 }
-00139 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
-00140 return true;
-00141 }
-00142
-00143
-00144 void ModeMakeList(char modechar)
-00145 {
-00146 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00147 {
-00148 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
-00149 {
-00150 i->list = true;
-00151 return;
-00152 }
-00153 }
-00154 return;
-00155 }
-00156
-00157
-00158
-00159 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { };
-00160
-00161
-00162
-00163 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
-00164
-00165 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { };
-00166
-00167 char* Request::GetData()
-00168 {
-00169 return this->data;
-00170 }
-00171
-00172 Module* Request::GetSource()
-00173 {
-00174 return this->source;
-00175 }
-00176
-00177 Module* Request::GetDest()
-00178 {
-00179 return this->dest;
-00180 }
-00181
-00182 char* Request::Send()
-00183 {
-00184 if (this->dest)
-00185 {
-00186 return dest->OnRequest(this);
-00187 }
-00188 else
-00189 {
-00190 return NULL;
-00191 }
-00192 }
-00193
-00194 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { };
-00195
-00196 char* Event::GetData()
-00197 {
-00198 return this->data;
-00199 }
-00200
-00201 Module* Event::GetSource()
-00202 {
-00203 return this->source;
-00204 }
-00205
-00206 char* Event::Send()
-00207 {
-00208 FOREACH_MOD OnEvent(this);
-00209 return NULL;
-00210 }
-00211
-00212 std::string Event::GetEventID()
-00213 {
-00214 return this->id;
-00215 }
+00060 extern time_t TIME;
+00061 class Server;
+00062 extern userrec* fd_ref_table[65536];
+00063
+00064 extern user_hash clientlist;
+00065 extern chan_hash chanlist;
+00066 extern command_table cmdlist;
+00067 ExtModeList EMode;
+00068
+00069
+00070 bool ModeDefined(char modechar, int type)
+00071 {
+00072 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00073 {
+00074 if ((i->modechar == modechar) && (i->type == type))
+00075 {
+00076 return true;
+00077 }
+00078 }
+00079 return false;
+00080 }
+00081
+00082 bool ModeIsListMode(char modechar, int type)
+00083 {
+00084 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00085 {
+00086 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
+00087 {
+00088 return true;
+00089 }
+00090 }
+00091 return false;
+00092 }
+00093
+00094 bool ModeDefinedOper(char modechar, int type)
+00095 {
+00096 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00097 {
+00098 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
+00099 {
+00100 return true;
+00101 }
+00102 }
+00103 return false;
+00104 }
+00105
+00106
+00107 int ModeDefinedOn(char modechar, int type)
+00108 {
+00109 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00110 {
+00111 if ((i->modechar == modechar) && (i->type == type))
+00112 {
+00113 return i->params_when_on;
+00114 }
+00115 }
+00116 return 0;
+00117 }
+00118
+00119
+00120 int ModeDefinedOff(char modechar, int type)
+00121 {
+00122 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00123 {
+00124 if ((i->modechar == modechar) && (i->type == type))
+00125 {
+00126 return i->params_when_off;
+00127 }
+00128 }
+00129 return 0;
+00130 }
+00131
+00132
+00133 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
+00134 {
+00135 if (ModeDefined(modechar,type)) {
+00136 return false;
+00137 }
+00138 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
+00139 return true;
+00140 }
+00141
+00142
+00143 void ModeMakeList(char modechar)
+00144 {
+00145 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00146 {
+00147 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
+00148 {
+00149 i->list = true;
+00150 return;
+00151 }
+00152 }
+00153 return;
+00154 }
+00155
+00156
+00157
+00158 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { };
+00159
+00160
+00161
+00162 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
+00163
+00164 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { };
+00165
+00166 char* Request::GetData()
+00167 {
+00168 return this->data;
+00169 }
+00170
+00171 Module* Request::GetSource()
+00172 {
+00173 return this->source;
+00174 }
+00175
+00176 Module* Request::GetDest()
+00177 {
+00178 return this->dest;
+00179 }
+00180
+00181 char* Request::Send()
+00182 {
+00183 if (this->dest)
+00184 {
+00185 return dest->OnRequest(this);
+00186 }
+00187 else
+00188 {
+00189 return NULL;
+00190 }
+00191 }
+00192
+00193 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { };
+00194
+00195 char* Event::GetData()
+00196 {
+00197 return this->data;
+00198 }
+00199
+00200 Module* Event::GetSource()
+00201 {
+00202 return this->source;
+00203 }
+00204
+00205 char* Event::Send()
+00206 {
+00207 FOREACH_MOD OnEvent(this);
+00208 return NULL;
+00209 }
+00210
+00211 std::string Event::GetEventID()
+00212 {
+00213 return this->id;
+00214 }
+00215
00216
-00217
-00218
-00219
-00220 Module::Module(Server* Me) { }
-00221 Module::~Module() { }
-00222 void Module::OnUserConnect(userrec* user) { }
-00223 void Module::OnUserQuit(userrec* user, std::string message) { }
-00224 void Module::OnUserDisconnect(userrec* user) { }
-00225 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-00226 void Module::OnUserPart(userrec* user, chanrec* channel) { }
-00227 void Module::OnRehash(std::string parameter) { }
-00228 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
-00229 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
-00230 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; }
-00231 void Module::OnMode(userrec* user, void* dest, int target_type, std::string text) { };
-00232 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
-00233 void Module::OnOper(userrec* user, std::string opertype) { };
-00234 void Module::OnInfo(userrec* user) { };
-00235 void Module::OnWhois(userrec* source, userrec* dest) { };
-00236 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
-00237 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
-00238 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
-00239 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
-00240 void Module::OnUserPostNick(userrec* user, std::string oldnick) { };
-00241 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
-00242 void Module::On005Numeric(std::string &output) { };
-00243 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; };
-00244 void Module::OnLoadModule(Module* mod,std::string name) { };
-00245 void Module::OnUnloadModule(Module* mod,std::string name) { };
-00246 void Module::OnBackgroundTimer(time_t curtime) { };
-00247 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { };
-00248 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; };
-00249 bool Module::OnCheckReady(userrec* user) { return true; };
-00250 void Module::OnUserRegister(userrec* user) { };
-00251 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; };
-00252 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { };
-00253 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; };
-00254 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
-00255 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
-00256 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
-00257 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
-00258 void Module::OnStats(char symbol) { };
-00259 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
-00260 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
-00261 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
-00262 void Module::OnEvent(Event* event) { return; };
-00263 char* Module::OnRequest(Request* request) { return NULL; };
-00264 int Module::OnOperCompare(std::string password, std::string input) { return 0; };
-00265 void Module::OnGlobalOper(userrec* user) { };
-00266 void Module::OnGlobalConnect(userrec* user) { };
-00267 int Module::OnAddBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
-00268 int Module::OnDelBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
-00269 void Module::OnRawSocketAccept(int fd, std::string ip, int localport) { };
-00270 int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; };
-00271 void Module::OnRawSocketClose(int fd) { };
-00272 int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; };
-00273 void Module::OnUserMessage(userrec* user, void* dest, int target_type, std::string text) { };
-00274 void Module::OnUserNotice(userrec* user, void* dest, int target_type, std::string text) { };
-00275 void Module::OnRemoteKill(userrec* source, userrec* dest, std::string reason) { };
-00276 void Module::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { };
-00277 void Module::OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { };
-00278 void Module::OnGetServerDescription(std::string servername,std::string &description) { };
-00279 void Module::OnSyncUser(userrec* user, Module* proto, void* opaque) { };
-00280 void Module::OnSyncChannel(chanrec* chan, Module* proto, void* opaque) { };
-00281 void Module::ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline) { };
-00282 void Module::OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, std::string extname) { };
-00283 void Module::OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, std::string extname) { };
-00284 void Module::OnDecodeMetaData(int target_type, void* target, std::string extname, std::string extdata) { };
-00285 void Module::ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata) { };
-00286 void Module::OnWallops(userrec* user, std::string text) { };
-00287 void Module::OnChangeHost(userrec* user, std::string newhost) { };
-00288 void Module::OnChangeName(userrec* user, std::string gecos) { };
-00289 void Module::OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask) { };
-00290 void Module::OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask) { };
-00291 void Module::OnAddKLine(long duration, userrec* source, std::string reason, std::string hostmask) { };
-00292 void Module::OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask) { };
-00293 void Module::OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask) { };
-00294 void Module::OnDelGLine(userrec* source, std::string hostmask) { };
-00295 void Module::OnDelZLine(userrec* source, std::string ipmask) { };
-00296 void Module::OnDelKLine(userrec* source, std::string hostmask) { };
-00297 void Module::OnDelQLine(userrec* source, std::string nickmask) { };
-00298 void Module::OnDelELine(userrec* source, std::string hostmask) { };
-00299 void Module::OnCleanup(int target_type, void* item) { };
-00300
-00301
-00302
-00303
-00304
-00305 Server::Server()
-00306 {
-00307 }
-00308
-00309 Server::~Server()
-00310 {
-00311 }
-00312
-00313 void Server::AddSocket(InspSocket* sock)
-00314 {
-00315 module_sockets.push_back(sock);
-00316 }
-00317
-00318 void Server::RehashServer()
-00319 {
-00320 WriteOpers("*** Rehashing config file");
-00321 Config->Read(false,NULL);
-00322 }
-00323
-00324 ServerConfig* Server::GetConfig()
-00325 {
-00326 return Config;
-00327 }
-00328
-00329 std::string Server::GetVersion()
-00330 {
-00331 return ServerInstance->GetVersionString();
-00332 }
-00333
-00334 void Server::DelSocket(InspSocket* sock)
-00335 {
-00336 for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
-00337 {
-00338 if (*a == sock)
-00339 {
-00340 module_sockets.erase(a);
-00341 return;
-00342 }
-00343 }
-00344 }
-00345
-00346 void Server::SendOpers(std::string s)
-00347 {
-00348 WriteOpers("%s",s.c_str());
-00349 }
-00350
-00351 bool Server::MatchText(std::string sliteral, std::string spattern)
-00352 {
-00353 char literal[MAXBUF],pattern[MAXBUF];
-00354 strlcpy(literal,sliteral.c_str(),MAXBUF);
-00355 strlcpy(pattern,spattern.c_str(),MAXBUF);
-00356 return match(literal,pattern);
-00357 }
-00358
-00359 void Server::SendToModeMask(std::string modes, int flags, std::string text)
-00360 {
-00361 WriteMode(modes.c_str(),flags,"%s",text.c_str());
-00362 }
-00363
-00364 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
-00365 {
-00366 return add_channel(user,cname.c_str(),key.c_str(),false);
-00367 }
-00368
-00369 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
-00370 {
-00371 return del_channel(user,cname.c_str(),reason.c_str(),false);
-00372 }
-00373
-00374 chanuserlist Server::GetUsers(chanrec* chan)
-00375 {
-00376 chanuserlist userl;
-00377 userl.clear();
-00378 std::vector<char*> *list = chan->GetUsers();
-00379 for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++)
-00380 {
-00381 char* o = *i;
-00382 userl.push_back((userrec*)o);
-00383 }
-00384 return userl;
-00385 }
-00386 void Server::ChangeUserNick(userrec* user, std::string nickname)
-00387 {
-00388 force_nickchange(user,nickname.c_str());
-00389 }
-00390
-00391 void Server::QuitUser(userrec* user, std::string reason)
-00392 {
-00393 kill_link(user,reason.c_str());
-00394 }
-00395
-00396 bool Server::IsUlined(std::string server)
-00397 {
-00398 return is_uline(server.c_str());
-00399 }
-00400
-00401 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
-00402 {
-00403 call_handler(commandname.c_str(),parameters,pcnt,user);
-00404 }
-00405
-00406 bool Server::IsValidModuleCommand(std::string commandname, int pcnt, userrec* user)
-00407 {
-00408 return is_valid_cmd(commandname.c_str(), pcnt, user);
-00409 }
-00410
-00411 void Server::Log(int level, std::string s)
-00412 {
-00413 log(level,"%s",s.c_str());
-00414 }
-00415
-00416 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source)
-00417 {
-00418 createcommand(cmd,f,flags,minparams,source);
-00419 }
-00420
-00421 void Server::SendMode(char **parameters, int pcnt, userrec *user)
-00422 {
-00423 server_mode(parameters,pcnt,user);
-00424 }
-00425
-00426 void Server::Send(int Socket, std::string s)
-00427 {
-00428 Write(Socket,"%s",s.c_str());
-00429 }
-00430
-00431 void Server::SendServ(int Socket, std::string s)
-00432 {
-00433 WriteServ(Socket,"%s",s.c_str());
-00434 }
-00435
-00436 void Server::SendFrom(int Socket, userrec* User, std::string s)
-00437 {
-00438 WriteFrom(Socket,User,"%s",s.c_str());
-00439 }
-00440
-00441 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
-00442 {
-00443 if (!Source)
-00444 {
-00445
-00446 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
-00447 }
-00448 else
-00449 {
-00450
-00451 WriteTo(Source,Dest,"%s",s.c_str());
-00452 }
-00453 }
-00454
-00455 void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text)
-00456 {
-00457 WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str());
-00458 }
-00459
-00460 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
-00461 {
-00462 if (IncludeSender)
-00463 {
-00464 WriteChannel(Channel,User,"%s",s.c_str());
-00465 }
-00466 else
-00467 {
-00468 ChanExceptSender(Channel,User,"%s",s.c_str());
-00469 }
-00470 }
-00471
-00472 bool Server::CommonChannels(userrec* u1, userrec* u2)
-00473 {
-00474 return (common_channels(u1,u2) != 0);
-00475 }
-00476
-00477 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
-00478 {
-00479 if (IncludeSender)
-00480 {
-00481 WriteCommon(User,"%s",text.c_str());
-00482 }
-00483 else
-00484 {
-00485 WriteCommonExcept(User,"%s",text.c_str());
-00486 }
-00487 }
-00488
-00489 void Server::SendWallops(userrec* User, std::string text)
-00490 {
-00491 WriteWallOps(User,false,"%s",text.c_str());
-00492 }
-00493
-00494 void Server::ChangeHost(userrec* user, std::string host)
-00495 {
-00496 ChangeDisplayedHost(user,host.c_str());
-00497 }
-00498
-00499 void Server::ChangeGECOS(userrec* user, std::string gecos)
-00500 {
-00501 ChangeName(user,gecos.c_str());
-00502 }
-00503
-00504 bool Server::IsNick(std::string nick)
-00505 {
-00506 return (isnick(nick.c_str()) != 0);
-00507 }
-00508
-00509 userrec* Server::FindNick(std::string nick)
-00510 {
-00511 return Find(nick);
-00512 }
-00513
-00514 userrec* Server::FindDescriptor(int socket)
-00515 {
-00516 return (socket < 65536 ? fd_ref_table[socket] : NULL);
-00517 }
-00518
-00519 chanrec* Server::FindChannel(std::string channel)
-00520 {
-00521 return FindChan(channel.c_str());
-00522 }
-00523
-00524 std::string Server::ChanMode(userrec* User, chanrec* Chan)
-00525 {
-00526 return cmode(User,Chan);
-00527 }
-00528
-00529 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
-00530 {
-00531 return has_channel(User,Chan);
-00532 }
-00533
-00534 std::string Server::GetServerName()
-00535 {
-00536 return Config->ServerName;
-00537 }
-00538
-00539 std::string Server::GetNetworkName()
-00540 {
-00541 return Config->Network;
-00542 }
-00543
-00544 std::string Server::GetServerDescription()
-00545 {
-00546 return Config->ServerDesc;
-00547 }
-00548
-00549 Admin Server::GetAdmin()
-00550 {
-00551 return Admin(Config->AdminName,Config->AdminEmail,Config->AdminNick);
-00552 }
+00217
+00218
+00219 Module::Module(Server* Me) { }
+00220 Module::~Module() { }
+00221 void Module::OnUserConnect(userrec* user) { }
+00222 void Module::OnUserQuit(userrec* user, std::string message) { }
+00223 void Module::OnUserDisconnect(userrec* user) { }
+00224 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
+00225 void Module::OnUserPart(userrec* user, chanrec* channel) { }
+00226 void Module::OnRehash(std::string parameter) { }
+00227 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
+00228 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
+00229 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; }
+00230 void Module::OnMode(userrec* user, void* dest, int target_type, std::string text) { };
+00231 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
+00232 void Module::OnOper(userrec* user, std::string opertype) { };
+00233 void Module::OnInfo(userrec* user) { };
+00234 void Module::OnWhois(userrec* source, userrec* dest) { };
+00235 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
+00236 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00237 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00238 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
+00239 void Module::OnUserPostNick(userrec* user, std::string oldnick) { };
+00240 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
+00241 void Module::On005Numeric(std::string &output) { };
+00242 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; };
+00243 void Module::OnLoadModule(Module* mod,std::string name) { };
+00244 void Module::OnUnloadModule(Module* mod,std::string name) { };
+00245 void Module::OnBackgroundTimer(time_t curtime) { };
+00246 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { };
+00247 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; };
+00248 bool Module::OnCheckReady(userrec* user) { return true; };
+00249 void Module::OnUserRegister(userrec* user) { };
+00250 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; };
+00251 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { };
+00252 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; };
+00253 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
+00254 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
+00255 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
+00256 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
+00257 void Module::OnStats(char symbol) { };
+00258 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
+00259 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
+00260 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
+00261 void Module::OnEvent(Event* event) { return; };
+00262 char* Module::OnRequest(Request* request) { return NULL; };
+00263 int Module::OnOperCompare(std::string password, std::string input) { return 0; };
+00264 void Module::OnGlobalOper(userrec* user) { };
+00265 void Module::OnGlobalConnect(userrec* user) { };
+00266 int Module::OnAddBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
+00267 int Module::OnDelBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
+00268 void Module::OnRawSocketAccept(int fd, std::string ip, int localport) { };
+00269 int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; };
+00270 void Module::OnRawSocketClose(int fd) { };
+00271 int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; };
+00272 void Module::OnUserMessage(userrec* user, void* dest, int target_type, std::string text) { };
+00273 void Module::OnUserNotice(userrec* user, void* dest, int target_type, std::string text) { };
+00274 void Module::OnRemoteKill(userrec* source, userrec* dest, std::string reason) { };
+00275 void Module::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { };
+00276 void Module::OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { };
+00277 void Module::OnGetServerDescription(std::string servername,std::string &description) { };
+00278 void Module::OnSyncUser(userrec* user, Module* proto, void* opaque) { };
+00279 void Module::OnSyncChannel(chanrec* chan, Module* proto, void* opaque) { };
+00280 void Module::ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline) { };
+00281 void Module::OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, std::string extname) { };
+00282 void Module::OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, std::string extname) { };
+00283 void Module::OnDecodeMetaData(int target_type, void* target, std::string extname, std::string extdata) { };
+00284 void Module::ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata) { };
+00285 void Module::OnWallops(userrec* user, std::string text) { };
+00286 void Module::OnChangeHost(userrec* user, std::string newhost) { };
+00287 void Module::OnChangeName(userrec* user, std::string gecos) { };
+00288 void Module::OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask) { };
+00289 void Module::OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask) { };
+00290 void Module::OnAddKLine(long duration, userrec* source, std::string reason, std::string hostmask) { };
+00291 void Module::OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask) { };
+00292 void Module::OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask) { };
+00293 void Module::OnDelGLine(userrec* source, std::string hostmask) { };
+00294 void Module::OnDelZLine(userrec* source, std::string ipmask) { };
+00295 void Module::OnDelKLine(userrec* source, std::string hostmask) { };
+00296 void Module::OnDelQLine(userrec* source, std::string nickmask) { };
+00297 void Module::OnDelELine(userrec* source, std::string hostmask) { };
+00298 void Module::OnCleanup(int target_type, void* item) { };
+00299
+00300
+00301
+00302
+00303
+00304 Server::Server()
+00305 {
+00306 }
+00307
+00308 Server::~Server()
+00309 {
+00310 }
+00311
+00312 void Server::AddSocket(InspSocket* sock)
+00313 {
+00314 module_sockets.push_back(sock);
+00315 }
+00316
+00317 void Server::RehashServer()
+00318 {
+00319 WriteOpers("*** Rehashing config file");
+00320 Config->Read(false,NULL);
+00321 }
+00322
+00323 ServerConfig* Server::GetConfig()
+00324 {
+00325 return Config;
+00326 }
+00327
+00328 std::string Server::GetVersion()
+00329 {
+00330 return ServerInstance->GetVersionString();
+00331 }
+00332
+00333 void Server::DelSocket(InspSocket* sock)
+00334 {
+00335 for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
+00336 {
+00337 if (*a == sock)
+00338 {
+00339 module_sockets.erase(a);
+00340 return;
+00341 }
+00342 }
+00343 }
+00344
+00345 void Server::SendOpers(std::string s)
+00346 {
+00347 WriteOpers("%s",s.c_str());
+00348 }
+00349
+00350 bool Server::MatchText(std::string sliteral, std::string spattern)
+00351 {
+00352 char literal[MAXBUF],pattern[MAXBUF];
+00353 strlcpy(literal,sliteral.c_str(),MAXBUF);
+00354 strlcpy(pattern,spattern.c_str(),MAXBUF);
+00355 return match(literal,pattern);
+00356 }
+00357
+00358 void Server::SendToModeMask(std::string modes, int flags, std::string text)
+00359 {
+00360 WriteMode(modes.c_str(),flags,"%s",text.c_str());
+00361 }
+00362
+00363 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
+00364 {
+00365 return add_channel(user,cname.c_str(),key.c_str(),false);
+00366 }
+00367
+00368 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
+00369 {
+00370 return del_channel(user,cname.c_str(),reason.c_str(),false);
+00371 }
+00372
+00373 chanuserlist Server::GetUsers(chanrec* chan)
+00374 {
+00375 chanuserlist userl;
+00376 userl.clear();
+00377 std::vector<char*> *list = chan->GetUsers();
+00378 for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++)
+00379 {
+00380 char* o = *i;
+00381 userl.push_back((userrec*)o);
+00382 }
+00383 return userl;
+00384 }
+00385 void Server::ChangeUserNick(userrec* user, std::string nickname)
+00386 {
+00387 force_nickchange(user,nickname.c_str());
+00388 }
+00389
+00390 void Server::QuitUser(userrec* user, std::string reason)
+00391 {
+00392 kill_link(user,reason.c_str());
+00393 }
+00394
+00395 bool Server::IsUlined(std::string server)
+00396 {
+00397 return is_uline(server.c_str());
+00398 }
+00399
+00400 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+00401 {
+00402 ServerInstance->Parser->CallHandler(commandname,parameters,pcnt,user);
+00403 }
+00404
+00405 bool Server::IsValidModuleCommand(std::string commandname, int pcnt, userrec* user)
+00406 {
+00407 return ServerInstance->Parser->IsValidCommand(commandname, pcnt, user);
+00408 }
+00409
+00410 void Server::Log(int level, std::string s)
+00411 {
+00412 log(level,"%s",s.c_str());
+00413 }
+00414
+00415 void Server::AddCommand(command_t *f)
+00416 {
+00417 ServerInstance->Parser->CreateCommand(f);
+00418 }
+00419
+00420 void Server::SendMode(char **parameters, int pcnt, userrec *user)
+00421 {
+00422 ServerInstance->ModeGrok->ServerMode(parameters,pcnt,user);
+00423 }
+00424
+00425 void Server::Send(int Socket, std::string s)
+00426 {
+00427 Write(Socket,"%s",s.c_str());
+00428 }
+00429
+00430 void Server::SendServ(int Socket, std::string s)
+00431 {
+00432 WriteServ(Socket,"%s",s.c_str());
+00433 }
+00434
+00435 void Server::SendFrom(int Socket, userrec* User, std::string s)
+00436 {
+00437 WriteFrom(Socket,User,"%s",s.c_str());
+00438 }
+00439
+00440 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
+00441 {
+00442 if (!Source)
+00443 {
+00444
+00445 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+00446 }
+00447 else
+00448 {
+00449
+00450 WriteTo(Source,Dest,"%s",s.c_str());
+00451 }
+00452 }
+00453
+00454 void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text)
+00455 {
+00456 WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str());
+00457 }
+00458
+00459 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
+00460 {
+00461 if (IncludeSender)
+00462 {
+00463 WriteChannel(Channel,User,"%s",s.c_str());
+00464 }
+00465 else
+00466 {
+00467 ChanExceptSender(Channel,User,"%s",s.c_str());
+00468 }
+00469 }
+00470
+00471 bool Server::CommonChannels(userrec* u1, userrec* u2)
+00472 {
+00473 return (common_channels(u1,u2) != 0);
+00474 }
+00475
+00476 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
+00477 {
+00478 if (IncludeSender)
+00479 {
+00480 WriteCommon(User,"%s",text.c_str());
+00481 }
+00482 else
+00483 {
+00484 WriteCommonExcept(User,"%s",text.c_str());
+00485 }
+00486 }
+00487
+00488 void Server::SendWallops(userrec* User, std::string text)
+00489 {
+00490 WriteWallOps(User,false,"%s",text.c_str());
+00491 }
+00492
+00493 void Server::ChangeHost(userrec* user, std::string host)
+00494 {
+00495 ChangeDisplayedHost(user,host.c_str());
+00496 }
+00497
+00498 void Server::ChangeGECOS(userrec* user, std::string gecos)
+00499 {
+00500 ChangeName(user,gecos.c_str());
+00501 }
+00502
+00503 bool Server::IsNick(std::string nick)
+00504 {
+00505 return (isnick(nick.c_str()) != 0);
+00506 }
+00507
+00508 userrec* Server::FindNick(std::string nick)
+00509 {
+00510 return Find(nick);
+00511 }
+00512
+00513 userrec* Server::FindDescriptor(int socket)
+00514 {
+00515 return (socket < 65536 ? fd_ref_table[socket] : NULL);
+00516 }
+00517
+00518 chanrec* Server::FindChannel(std::string channel)
+00519 {
+00520 return FindChan(channel.c_str());
+00521 }
+00522
+00523 std::string Server::ChanMode(userrec* User, chanrec* Chan)
+00524 {
+00525 return cmode(User,Chan);
+00526 }
+00527
+00528 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
+00529 {
+00530 return has_channel(User,Chan);
+00531 }
+00532
+00533 std::string Server::GetServerName()
+00534 {
+00535 return Config->ServerName;
+00536 }
+00537
+00538 std::string Server::GetNetworkName()
+00539 {
+00540 return Config->Network;
+00541 }
+00542
+00543 std::string Server::GetServerDescription()
+00544 {
+00545 return Config->ServerDesc;
+00546 }
+00547
+00548 Admin Server::GetAdmin()
+00549 {
+00550 return Admin(Config->AdminName,Config->AdminEmail,Config->AdminNick);
+00551 }
+00552
00553
00554
-00555
-00556 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
-00557 {
-00558 if (((modechar >= 'A') && (modechar <= 'Z')) || ((modechar >= 'a') && (modechar <= 'z')))
-00559 {
-00560 if (type == MT_SERVER)
-00561 {
-00562 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
-00563 return false;
-00564 }
-00565 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
-00566 {
-00567 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
-00568 return false;
-00569 }
-00570 if ((params_when_on>1) || (params_when_off>1))
-00571 {
-00572 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
-00573 return false;
-00574 }
-00575 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
-00576 }
-00577 else
-00578 {
-00579 log(DEBUG,"*** API ERROR *** Muppet modechar detected.");
-00580 }
-00581 return false;
-00582 }
-00583
-00584 bool Server::AddExtendedListMode(char modechar)
-00585 {
-00586 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
-00587 if (res)
-00588 ModeMakeList(modechar);
-00589 return res;
-00590 }
-00591
-00592 int Server::CountUsers(chanrec* c)
-00593 {
-00594 return usercount(c);
-00595 }
+00555 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
+00556 {
+00557 if (((modechar >= 'A') && (modechar <= 'Z')) || ((modechar >= 'a') && (modechar <= 'z')))
+00558 {
+00559 if (type == MT_SERVER)
+00560 {
+00561 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
+00562 return false;
+00563 }
+00564 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
+00565 {
+00566 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
+00567 return false;
+00568 }
+00569 if ((params_when_on>1) || (params_when_off>1))
+00570 {
+00571 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
+00572 return false;
+00573 }
+00574 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
+00575 }
+00576 else
+00577 {
+00578 log(DEBUG,"*** API ERROR *** Muppet modechar detected.");
+00579 }
+00580 return false;
+00581 }
+00582
+00583 bool Server::AddExtendedListMode(char modechar)
+00584 {
+00585 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
+00586 if (res)
+00587 ModeMakeList(modechar);
+00588 return res;
+00589 }
+00590
+00591 int Server::CountUsers(chanrec* c)
+00592 {
+00593 return usercount(c);
+00594 }
+00595
00596
-00597
-00598 bool Server::UserToPseudo(userrec* user,std::string message)
-00599 {
-00600 unsigned int old_fd = user->fd;
-00601 user->fd = FD_MAGIC_NUMBER;
-00602 user->ClearBuffer();
-00603 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
-00604 SE->DelFd(old_fd);
-00605 shutdown(old_fd,2);
-00606 close(old_fd);
-00607 return true;
-00608 }
-00609
-00610 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message)
-00611 {
-00612 zombie->fd = alive->fd;
-00613 alive->fd = FD_MAGIC_NUMBER;
-00614 alive->ClearBuffer();
-00615 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick);
-00616 kill_link(alive,message.c_str());
-00617 fd_ref_table[zombie->fd] = zombie;
-00618 for (unsigned int i = 0; i < zombie->chans.size(); i++)
-00619 {
-00620 if (zombie->chans[i].channel != NULL)
-00621 {
-00622 if (zombie->chans[i].channel->name)
-00623 {
-00624 chanrec* Ptr = zombie->chans[i].channel;
-00625 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name);
-00626 if (Ptr->topicset)
-00627 {
-00628 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
-00629 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
-00630 }
-00631 userlist(zombie,Ptr);
-00632 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
-00633
-00634 }
-00635 }
-00636 }
-00637 return true;
-00638 }
-00639
-00640 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask)
-00641 {
-00642 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00643 }
-00644
-00645 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname)
-00646 {
-00647 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str());
-00648 }
-00649
-00650 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr)
-00651 {
-00652 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str());
-00653 }
-00654
-00655 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask)
-00656 {
-00657 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00658 }
-00659
-00660 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask)
-00661 {
-00662 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00663 }
-00664
-00665 bool Server::DelGLine(std::string hostmask)
-00666 {
-00667 return del_gline(hostmask.c_str());
-00668 }
-00669
-00670 bool Server::DelQLine(std::string nickname)
-00671 {
-00672 return del_qline(nickname.c_str());
-00673 }
-00674
-00675 bool Server::DelZLine(std::string ipaddr)
-00676 {
-00677 return del_zline(ipaddr.c_str());
-00678 }
-00679
-00680 bool Server::DelKLine(std::string hostmask)
-00681 {
-00682 return del_kline(hostmask.c_str());
-00683 }
-00684
-00685 bool Server::DelELine(std::string hostmask)
-00686 {
-00687 return del_eline(hostmask.c_str());
-00688 }
-00689
-00690 long Server::CalcDuration(std::string delta)
-00691 {
-00692 return duration(delta.c_str());
-00693 }
-00694
-00695 bool Server::IsValidMask(std::string mask)
-00696 {
-00697 const char* dest = mask.c_str();
-00698 if (strchr(dest,'!')==0)
-00699 return false;
-00700 if (strchr(dest,'@')==0)
-00701 return false;
-00702 for (unsigned int i = 0; i < strlen(dest); i++)
-00703 if (dest[i] < 32)
-00704 return false;
-00705 for (unsigned int i = 0; i < strlen(dest); i++)
-00706 if (dest[i] > 126)
-00707 return false;
-00708 unsigned int c = 0;
-00709 for (unsigned int i = 0; i < strlen(dest); i++)
-00710 if (dest[i] == '!')
-00711 c++;
-00712 if (c>1)
-00713 return false;
-00714 c = 0;
-00715 for (unsigned int i = 0; i < strlen(dest); i++)
-00716 if (dest[i] == '@')
-00717 c++;
-00718 if (c>1)
-00719 return false;
-00720
-00721 return true;
-00722 }
-00723
-00724 Module* Server::FindModule(std::string name)
-00725 {
-00726 for (int i = 0; i <= MODCOUNT; i++)
-00727 {
-00728 if (Config->module_names[i] == name)
-00729 {
-00730 return modules[i];
-00731 }
-00732 }
-00733 return NULL;
-00734 }
-00735
-00736 ConfigReader::ConfigReader()
-00737 {
-00738 Config->ClearStack();
-00739 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00740 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00741 this->readerror = Config->LoadConf(CONFIG_FILE,this->cache,this->errorlog);
-00742 if (!this->readerror)
-00743 this->error = CONF_FILE_NOT_FOUND;
-00744 }
+00597 bool Server::UserToPseudo(userrec* user,std::string message)
+00598 {
+00599 unsigned int old_fd = user->fd;
+00600 user->fd = FD_MAGIC_NUMBER;
+00601 user->ClearBuffer();
+00602 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
+00603 ServerInstance->SE->DelFd(old_fd);
+00604 shutdown(old_fd,2);
+00605 close(old_fd);
+00606 return true;
+00607 }
+00608
+00609 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message)
+00610 {
+00611 zombie->fd = alive->fd;
+00612 alive->fd = FD_MAGIC_NUMBER;
+00613 alive->ClearBuffer();
+00614 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick);
+00615 kill_link(alive,message.c_str());
+00616 fd_ref_table[zombie->fd] = zombie;
+00617 for (unsigned int i = 0; i < zombie->chans.size(); i++)
+00618 {
+00619 if (zombie->chans[i].channel != NULL)
+00620 {
+00621 if (zombie->chans[i].channel->name)
+00622 {
+00623 chanrec* Ptr = zombie->chans[i].channel;
+00624 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name);
+00625 if (Ptr->topicset)
+00626 {
+00627 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
+00628 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
+00629 }
+00630 userlist(zombie,Ptr);
+00631 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
+00632
+00633 }
+00634 }
+00635 }
+00636 return true;
+00637 }
+00638
+00639 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask)
+00640 {
+00641 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00642 }
+00643
+00644 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname)
+00645 {
+00646 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str());
+00647 }
+00648
+00649 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr)
+00650 {
+00651 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str());
+00652 }
+00653
+00654 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask)
+00655 {
+00656 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00657 }
+00658
+00659 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask)
+00660 {
+00661 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00662 }
+00663
+00664 bool Server::DelGLine(std::string hostmask)
+00665 {
+00666 return del_gline(hostmask.c_str());
+00667 }
+00668
+00669 bool Server::DelQLine(std::string nickname)
+00670 {
+00671 return del_qline(nickname.c_str());
+00672 }
+00673
+00674 bool Server::DelZLine(std::string ipaddr)
+00675 {
+00676 return del_zline(ipaddr.c_str());
+00677 }
+00678
+00679 bool Server::DelKLine(std::string hostmask)
+00680 {
+00681 return del_kline(hostmask.c_str());
+00682 }
+00683
+00684 bool Server::DelELine(std::string hostmask)
+00685 {
+00686 return del_eline(hostmask.c_str());
+00687 }
+00688
+00689 long Server::CalcDuration(std::string delta)
+00690 {
+00691 return duration(delta.c_str());
+00692 }
+00693
+00694 bool Server::IsValidMask(std::string mask)
+00695 {
+00696 const char* dest = mask.c_str();
+00697 if (strchr(dest,'!')==0)
+00698 return false;
+00699 if (strchr(dest,'@')==0)
+00700 return false;
+00701 for (unsigned int i = 0; i < strlen(dest); i++)
+00702 if (dest[i] < 32)
+00703 return false;
+00704 for (unsigned int i = 0; i < strlen(dest); i++)
+00705 if (dest[i] > 126)
+00706 return false;
+00707 unsigned int c = 0;
+00708 for (unsigned int i = 0; i < strlen(dest); i++)
+00709 if (dest[i] == '!')
+00710 c++;
+00711 if (c>1)
+00712 return false;
+00713 c = 0;
+00714 for (unsigned int i = 0; i < strlen(dest); i++)
+00715 if (dest[i] == '@')
+00716 c++;
+00717 if (c>1)
+00718 return false;
+00719
+00720 return true;
+00721 }
+00722
+00723 Module* Server::FindModule(std::string name)
+00724 {
+00725 for (int i = 0; i <= MODCOUNT; i++)
+00726 {
+00727 if (Config->module_names[i] == name)
+00728 {
+00729 return modules[i];
+00730 }
+00731 }
+00732 return NULL;
+00733 }
+00734
+00735 ConfigReader::ConfigReader()
+00736 {
+00737 Config->ClearStack();
+00738 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00739 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00740 this->readerror = Config->LoadConf(CONFIG_FILE,this->cache,this->errorlog);
+00741 if (!this->readerror)
+00742 this->error = CONF_FILE_NOT_FOUND;
+00743 }
+00744
00745
-00746
-00747 ConfigReader::~ConfigReader()
-00748 {
-00749 if (this->cache)
-00750 delete this->cache;
-00751 if (this->errorlog)
-00752 delete this->errorlog;
-00753 }
+00746 ConfigReader::~ConfigReader()
+00747 {
+00748 if (this->cache)
+00749 delete this->cache;
+00750 if (this->errorlog)
+00751 delete this->errorlog;
+00752 }
+00753
00754
-00755
-00756 ConfigReader::ConfigReader(std::string filename)
-00757 {
-00758 Config->ClearStack();
-00759 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00760 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00761 this->readerror = Config->LoadConf(filename.c_str(),this->cache,this->errorlog);
-00762 if (!this->readerror)
-00763 this->error = CONF_FILE_NOT_FOUND;
-00764 };
-00765
-00766 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
-00767 {
-00768 char val[MAXBUF];
-00769 char t[MAXBUF];
-00770 char n[MAXBUF];
-00771 strlcpy(t,tag.c_str(),MAXBUF);
-00772 strlcpy(n,name.c_str(),MAXBUF);
-00773 int res = Config->ReadConf(cache,t,n,index,val);
-00774 if (!res)
-00775 {
-00776 this->error = CONF_VALUE_NOT_FOUND;
-00777 return "";
-00778 }
-00779 return val;
-00780 }
-00781
-00782 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
-00783 {
-00784 char val[MAXBUF];
-00785 char t[MAXBUF];
-00786 char n[MAXBUF];
-00787 strlcpy(t,tag.c_str(),MAXBUF);
-00788 strlcpy(n,name.c_str(),MAXBUF);
-00789 int res = Config->ReadConf(cache,t,n,index,val);
-00790 if (!res)
-00791 {
-00792 this->error = CONF_VALUE_NOT_FOUND;
-00793 return false;
-00794 }
-00795 std::string s = val;
-00796 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
-00797 }
-00798
-00799 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
-00800 {
-00801 char val[MAXBUF];
-00802 char t[MAXBUF];
-00803 char n[MAXBUF];
-00804 strlcpy(t,tag.c_str(),MAXBUF);
-00805 strlcpy(n,name.c_str(),MAXBUF);
-00806 int res = Config->ReadConf(cache,t,n,index,val);
-00807 if (!res)
-00808 {
-00809 this->error = CONF_VALUE_NOT_FOUND;
-00810 return 0;
-00811 }
-00812 for (unsigned int i = 0; i < strlen(val); i++)
-00813 {
-00814 if (!isdigit(val[i]))
-00815 {
-00816 this->error = CONF_NOT_A_NUMBER;
-00817 return 0;
-00818 }
-00819 }
-00820 if ((needs_unsigned) && (atoi(val)<0))
-00821 {
-00822 this->error = CONF_NOT_UNSIGNED;
-00823 return 0;
-00824 }
-00825 return atoi(val);
-00826 }
-00827
-00828 long ConfigReader::GetError()
-00829 {
-00830 long olderr = this->error;
-00831 this->error = 0;
-00832 return olderr;
-00833 }
-00834
-00835 void ConfigReader::DumpErrors(bool bail, userrec* user)
-00836 {
-00837 if (bail)
-00838 {
-00839 printf("There were errors in your configuration:\n%s",errorlog->str().c_str());
-00840 exit(0);
-00841 }
-00842 else
-00843 {
-00844 char dataline[1024];
-00845 if (user)
-00846 {
-00847 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
-00848 while (!errorlog->eof())
-00849 {
-00850 errorlog->getline(dataline,1024);
-00851 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
-00852 }
-00853 }
-00854 else
-00855 {
-00856 WriteOpers("There were errors in the configuration file:",user->nick);
-00857 while (!errorlog->eof())
-00858 {
-00859 errorlog->getline(dataline,1024);
-00860 WriteOpers(dataline);
-00861 }
-00862 }
-00863 return;
-00864 }
-00865 }
+00755 ConfigReader::ConfigReader(std::string filename)
+00756 {
+00757 Config->ClearStack();
+00758 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00759 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00760 this->readerror = Config->LoadConf(filename.c_str(),this->cache,this->errorlog);
+00761 if (!this->readerror)
+00762 this->error = CONF_FILE_NOT_FOUND;
+00763 };
+00764
+00765 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
+00766 {
+00767 char val[MAXBUF];
+00768 char t[MAXBUF];
+00769 char n[MAXBUF];
+00770 strlcpy(t,tag.c_str(),MAXBUF);
+00771 strlcpy(n,name.c_str(),MAXBUF);
+00772 int res = Config->ReadConf(cache,t,n,index,val);
+00773 if (!res)
+00774 {
+00775 this->error = CONF_VALUE_NOT_FOUND;
+00776 return "";
+00777 }
+00778 return val;
+00779 }
+00780
+00781 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
+00782 {
+00783 char val[MAXBUF];
+00784 char t[MAXBUF];
+00785 char n[MAXBUF];
+00786 strlcpy(t,tag.c_str(),MAXBUF);
+00787 strlcpy(n,name.c_str(),MAXBUF);
+00788 int res = Config->ReadConf(cache,t,n,index,val);
+00789 if (!res)
+00790 {
+00791 this->error = CONF_VALUE_NOT_FOUND;
+00792 return false;
+00793 }
+00794 std::string s = val;
+00795 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
+00796 }
+00797
+00798 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
+00799 {
+00800 char val[MAXBUF];
+00801 char t[MAXBUF];
+00802 char n[MAXBUF];
+00803 strlcpy(t,tag.c_str(),MAXBUF);
+00804 strlcpy(n,name.c_str(),MAXBUF);
+00805 int res = Config->ReadConf(cache,t,n,index,val);
+00806 if (!res)
+00807 {
+00808 this->error = CONF_VALUE_NOT_FOUND;
+00809 return 0;
+00810 }
+00811 for (unsigned int i = 0; i < strlen(val); i++)
+00812 {
+00813 if (!isdigit(val[i]))
+00814 {
+00815 this->error = CONF_NOT_A_NUMBER;
+00816 return 0;
+00817 }
+00818 }
+00819 if ((needs_unsigned) && (atoi(val)<0))
+00820 {
+00821 this->error = CONF_NOT_UNSIGNED;
+00822 return 0;
+00823 }
+00824 return atoi(val);
+00825 }
+00826
+00827 long ConfigReader::GetError()
+00828 {
+00829 long olderr = this->error;
+00830 this->error = 0;
+00831 return olderr;
+00832 }
+00833
+00834 void ConfigReader::DumpErrors(bool bail, userrec* user)
+00835 {
+00836 if (bail)
+00837 {
+00838 printf("There were errors in your configuration:\n%s",errorlog->str().c_str());
+00839 exit(0);
+00840 }
+00841 else
+00842 {
+00843 char dataline[1024];
+00844 if (user)
+00845 {
+00846 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
+00847 while (!errorlog->eof())
+00848 {
+00849 errorlog->getline(dataline,1024);
+00850 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
+00851 }
+00852 }
+00853 else
+00854 {
+00855 WriteOpers("There were errors in the configuration file:",user->nick);
+00856 while (!errorlog->eof())
+00857 {
+00858 errorlog->getline(dataline,1024);
+00859 WriteOpers(dataline);
+00860 }
+00861 }
+00862 return;
+00863 }
+00864 }
+00865
00866
-00867
-00868 int ConfigReader::Enumerate(std::string tag)
-00869 {
-00870 return Config->EnumConf(cache,tag.c_str());
-00871 }
-00872
-00873 int ConfigReader::EnumerateValues(std::string tag, int index)
-00874 {
-00875 return Config->EnumValues(cache, tag.c_str(), index);
-00876 }
-00877
-00878 bool ConfigReader::Verify()
-00879 {
-00880 return this->readerror;
-00881 }
+00867 int ConfigReader::Enumerate(std::string tag)
+00868 {
+00869 return Config->EnumConf(cache,tag.c_str());
+00870 }
+00871
+00872 int ConfigReader::EnumerateValues(std::string tag, int index)
+00873 {
+00874 return Config->EnumValues(cache, tag.c_str(), index);
+00875 }
+00876
+00877 bool ConfigReader::Verify()
+00878 {
+00879 return this->readerror;
+00880 }
+00881
00882
-00883
-00884 FileReader::FileReader(std::string filename)
-00885 {
-00886 file_cache c;
-00887 readfile(c,filename.c_str());
-00888 this->fc = c;
-00889 }
-00890
-00891 FileReader::FileReader()
-00892 {
-00893 }
-00894
-00895 void FileReader::LoadFile(std::string filename)
-00896 {
-00897 file_cache c;
-00898 readfile(c,filename.c_str());
-00899 this->fc = c;
-00900 }
+00883 FileReader::FileReader(std::string filename)
+00884 {
+00885 file_cache c;
+00886 readfile(c,filename.c_str());
+00887 this->fc = c;
+00888 }
+00889
+00890 FileReader::FileReader()
+00891 {
+00892 }
+00893
+00894 void FileReader::LoadFile(std::string filename)
+00895 {
+00896 file_cache c;
+00897 readfile(c,filename.c_str());
+00898 this->fc = c;
+00899 }
+00900
00901
-00902
-00903 FileReader::~FileReader()
-00904 {
-00905 }
-00906
-00907 bool FileReader::Exists()
-00908 {
-00909 if (fc.size() == 0)
-00910 {
-00911 return(false);
-00912 }
-00913 else
-00914 {
-00915 return(true);
-00916 }
-00917 }
-00918
-00919 std::string FileReader::GetLine(int x)
-00920 {
-00921 if ((x<0) || ((unsigned)x>fc.size()))
-00922 return "";
-00923 return fc[x];
-00924 }
-00925
-00926 int FileReader::FileSize()
-00927 {
-00928 return fc.size();
-00929 }
+00902 FileReader::~FileReader()
+00903 {
+00904 }
+00905
+00906 bool FileReader::Exists()
+00907 {
+00908 if (fc.size() == 0)
+00909 {
+00910 return(false);
+00911 }
+00912 else
+00913 {
+00914 return(true);
+00915 }
+00916 }
+00917
+00918 std::string FileReader::GetLine(int x)
+00919 {
+00920 if ((x<0) || ((unsigned)x>fc.size()))
+00921 return "";
+00922 return fc[x];
+00923 }
+00924
+00925 int FileReader::FileSize()
+00926 {
+00927 return fc.size();
+00928 }
+00929
00930
-00931
-00932 std::vector<Module*> modules(255);
-00933 std::vector<ircd_module*> factory(255);
-00934
-00935 int MODCOUNT = -1;
+00931 std::vector<Module*> modules(255);
+00932 std::vector<ircd_module*> factory(255);
+00933
+00934 int MODCOUNT = -1;
+00935
00936
-00937
-
Generated on Thu Dec 15 11:14:14 2005 for InspIRCd by
+
Generated on Mon Dec 19 18:02:13 2005 for InspIRCd by
1.4.4-20050815
--
cgit v1.3.1-10-gc9f91