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