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