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