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