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