X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=docs%2Fmodule-doc%2Fmodules_8cpp-source.html;h=fd9f62d41580f7af5c43667a30b25fc7ecfd54b6;hb=3d7312f8af1becdbe458392e14ea64c904ee7b92;hp=6e69399785d1c72ef6644a42e16182ce09a9f37a;hpb=0f2cf28d39404881b9719330ca86757c51b87bad;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/docs/module-doc/modules_8cpp-source.html b/docs/module-doc/modules_8cpp-source.html index 6e6939978..fd9f62d41 100644 --- a/docs/module-doc/modules_8cpp-source.html +++ b/docs/module-doc/modules_8cpp-source.html @@ -1,730 +1,791 @@
-00001 #include "inspircd.h" -00002 #include "inspircd_io.h" -00003 #include "inspircd_util.h" -00004 #include "inspircd_config.h" -00005 #include <unistd.h> -00006 #include <fcntl.h> -00007 #include <sys/errno.h> -00008 #include <sys/ioctl.h> -00009 #include <sys/utsname.h> -00010 #include <cstdio> -00011 #include <time.h> -00012 #include <string> -00013 #ifdef GCC3 -00014 #include <ext/hash_map> -00015 #else -00016 #include <hash_map> -00017 #endif -00018 #include <map> -00019 #include <sstream> -00020 #include <vector> -00021 #include <errno.h> -00022 #include <deque> -00023 #include <errno.h> -00024 #include <unistd.h> -00025 #include <sched.h> -00026 #include "connection.h" -00027 #include "users.h" -00028 #include "servers.h" -00029 #include "ctables.h" -00030 #include "globals.h" -00031 #include "modules.h" -00032 #include "dynamic.h" -00033 #include "wildcard.h" -00034 #include "message.h" -00035 #include "mode.h" -00036 #include "xline.h" -00037 #include "commands.h" -00038 -00039 #ifdef GCC3 -00040 #define nspace __gnu_cxx -00041 #else -00042 #define nspace std -00043 #endif -00044 -00045 using namespace std; -00046 -00047 extern int MODCOUNT; -00048 extern vector<Module*> modules; -00049 extern vector<ircd_module*> factory; -00050 -00051 extern int LogLevel; -00052 extern char ServerName[MAXBUF]; -00053 extern char Network[MAXBUF]; -00054 extern char ServerDesc[MAXBUF]; -00055 extern char AdminName[MAXBUF]; -00056 extern char AdminEmail[MAXBUF]; -00057 extern char AdminNick[MAXBUF]; -00058 extern char diepass[MAXBUF]; -00059 extern char restartpass[MAXBUF]; -00060 extern char motd[MAXBUF]; -00061 extern char rules[MAXBUF]; -00062 extern char list[MAXBUF]; -00063 extern char PrefixQuit[MAXBUF]; -00064 extern char DieValue[MAXBUF]; -00065 -00066 extern int debugging; -00067 extern int WHOWAS_STALE; -00068 extern int WHOWAS_MAX; -00069 extern int DieDelay; -00070 extern time_t startup_time; -00071 extern int NetBufferSize; -00072 extern int MaxWhoResults; -00073 extern time_t nb_start; -00074 -00075 extern std::vector<int> fd_reap; -00076 extern std::vector<std::string> module_names; -00077 -00078 extern char bannerBuffer[MAXBUF]; -00079 extern int boundPortCount; -00080 extern int portCount; -00081 extern int UDPportCount; -00082 extern int ports[MAXSOCKS]; -00083 extern int defaultRoute; + +Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members+modules.cpp
Go to the documentation of this file.00001 /* +------------------------------------+ +00002 * | Inspire Internet Relay Chat Daemon | +00003 * +------------------------------------+ +00004 * +00005 * Inspire is copyright (C) 2002-2004 ChatSpike-Dev. +00006 * E-mail: +00007 * <brain@chatspike.net> +00008 * <Craig@chatspike.net> +00009 * +00010 * Written by Craig Edwards, Craig McLure, and others. +00011 * This program is free but copyrighted software; see +00012 * the file COPYING for details. +00013 * +00014 * --------------------------------------------------- +00015 */ +00016 +00017 #include "inspircd.h" +00018 #include "inspircd_io.h" +00019 #include "inspircd_util.h" +00020 #include "inspircd_config.h" +00021 #include <unistd.h> +00022 #include <fcntl.h> +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 std::vector<long> auth_cookies; -00086 extern std::stringstream config_f; -00087 -00088 extern serverrec* me[32]; -00089 -00090 extern FILE *log_file; -00091 -00092 -00093 namespace nspace -00094 { -00095 template<> struct nspace::hash<in_addr> -00096 { -00097 size_t operator()(const struct in_addr &a) const -00098 { -00099 size_t q; -00100 memcpy(&q,&a,sizeof(size_t)); -00101 return q; -00102 } -00103 }; -00104 -00105 template<> struct nspace::hash<string> -00106 { -00107 size_t operator()(const string &s) const -00108 { -00109 char a[MAXBUF]; -00110 static struct hash<const char *> strhash; -00111 strcpy(a,s.c_str()); -00112 strlower(a); -00113 return strhash(a); -00114 } -00115 }; -00116 } -00117 -00118 -00119 struct StrHashComp -00120 { -00121 -00122 bool operator()(const string& s1, const string& s2) const -00123 { -00124 char a[MAXBUF],b[MAXBUF]; -00125 strcpy(a,s1.c_str()); -00126 strcpy(b,s2.c_str()); -00127 return (strcasecmp(a,b) == 0); -00128 } -00129 -00130 }; -00131 -00132 struct InAddr_HashComp -00133 { -00134 -00135 bool operator()(const in_addr &s1, const in_addr &s2) const -00136 { -00137 size_t q; -00138 size_t p; -00139 -00140 memcpy(&q,&s1,sizeof(size_t)); -00141 memcpy(&p,&s2,sizeof(size_t)); -00142 -00143 return (q == p); -00144 } +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; +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; +00102 +00103 extern std::vector<long> auth_cookies; +00104 extern std::stringstream config_f; +00105 +00106 extern serverrec* me[32]; +00107 +00108 extern FILE *log_file; +00109 +00110 +00111 namespace nspace +00112 { +00113 #ifdef GCC34 +00114 template<> struct hash<in_addr> +00115 #else +00116 template<> struct nspace::hash<in_addr> +00117 #endif +00118 { +00119 size_t operator()(const struct in_addr &a) const +00120 { +00121 size_t q; +00122 memcpy(&q,&a,sizeof(size_t)); +00123 return q; +00124 } +00125 }; +00126 #ifdef GCC34 +00127 template<> struct hash<string> +00128 #else +00129 template<> struct nspace::hash<string> +00130 #endif +00131 { +00132 size_t operator()(const string &s) const +00133 { +00134 char a[MAXBUF]; +00135 static struct hash<const char *> strhash; +00136 strlcpy(a,s.c_str(),MAXBUF); +00137 strlower(a); +00138 return strhash(a); +00139 } +00140 }; +00141 } +00142 +00143 struct StrHashComp +00144 { 00145 -00146 }; -00147 -00148 -00149 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash; -00150 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash; -00151 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache; -00152 typedef std::deque<command_t> command_table; +00146 bool operator()(const string& s1, const string& s2) const +00147 { +00148 char a[MAXBUF],b[MAXBUF]; +00149 strlcpy(a,s1.c_str(),MAXBUF); +00150 strlcpy(b,s2.c_str(),MAXBUF); +00151 return (strcasecmp(a,b) == 0); +00152 } 00153 -00154 -00155 extern user_hash clientlist; -00156 extern chan_hash chanlist; -00157 extern user_hash whowas; -00158 extern command_table cmdlist; -00159 extern file_cache MOTD; -00160 extern file_cache RULES; -00161 extern address_cache IP; -00162 -00163 -00164 // class type for holding an extended mode character - internal to core -00165 -00166 class ExtMode : public classbase -00167 { -00168 public: -00169 char modechar; -00170 int type; -00171 int params_when_on; -00172 int params_when_off; -00173 bool needsoper; -00174 bool list; -00175 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) { }; -00176 }; +00154 }; +00155 +00156 struct InAddr_HashComp +00157 { +00158 +00159 bool operator()(const in_addr &s1, const in_addr &s2) const +00160 { +00161 size_t q; +00162 size_t p; +00163 +00164 memcpy(&q,&s1,sizeof(size_t)); +00165 memcpy(&p,&s2,sizeof(size_t)); +00166 +00167 return (q == p); +00168 } +00169 +00170 }; +00171 +00172 +00173 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash; +00174 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash; +00175 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache; +00176 typedef std::deque<command_t> command_table; 00177 -00178 typedef std::vector<ExtMode> ExtModeList; -00179 typedef ExtModeList::iterator ExtModeListIter; -00180 -00181 -00182 ExtModeList EMode; -00183 -00184 // returns true if an extended mode character is in use -00185 bool ModeDefined(char modechar, int type) -00186 { -00187 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); -00188 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00189 { -00190 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type); -00191 if ((i->modechar == modechar) && (i->type == type)) -00192 { -00193 return true; -00194 } -00195 } -00196 return false; -00197 } -00198 -00199 bool ModeIsListMode(char modechar, int type) -00200 { -00201 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); -00202 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00203 { -00204 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type); -00205 if ((i->modechar == modechar) && (i->type == type) && (i->list == true)) -00206 { -00207 return true; -00208 } -00209 } -00210 return false; -00211 } -00212 -00213 bool ModeDefinedOper(char modechar, int type) -00214 { -00215 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); -00216 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00217 { -00218 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type); -00219 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true)) -00220 { -00221 return true; -00222 } -00223 } -00224 return false; -00225 } -00226 -00227 // returns number of parameters for a custom mode when it is switched on -00228 int ModeDefinedOn(char modechar, int type) -00229 { -00230 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00231 { -00232 if ((i->modechar == modechar) && (i->type == type)) -00233 { -00234 return i->params_when_on; -00235 } -00236 } -00237 return 0; -00238 } -00239 -00240 // returns number of parameters for a custom mode when it is switched on -00241 int ModeDefinedOff(char modechar, int type) -00242 { -00243 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00244 { -00245 if ((i->modechar == modechar) && (i->type == type)) -00246 { -00247 return i->params_when_off; -00248 } -00249 } -00250 return 0; -00251 } -00252 -00253 // returns true if an extended mode character is in use -00254 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off) -00255 { -00256 if (ModeDefined(modechar,type)) { -00257 return false; -00258 } -00259 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off)); -00260 return true; -00261 } -00262 -00263 // turns a mode into a listmode -00264 void ModeMakeList(char modechar) -00265 { -00266 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00267 { -00268 if ((i->modechar == modechar) && (i->type == MT_CHANNEL)) -00269 { -00270 i->list = true; -00271 return; -00272 } -00273 } -00274 return; -00275 } -00276 -00277 // version is a simple class for holding a modules version number -00278 -00279 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { }; -00280 -00281 // admin is a simple class for holding a server's administrative info -00282 -00283 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { }; -00284 -00285 Module::Module() { } -00286 Module::~Module() { } -00287 void Module::OnUserConnect(userrec* user) { } -00288 void Module::OnUserQuit(userrec* user) { } -00289 void Module::OnUserJoin(userrec* user, chanrec* channel) { } -00290 void Module::OnUserPart(userrec* user, chanrec* channel) { } -00291 void Module::OnPacketTransmit(char *p) { } -00292 void Module::OnPacketReceive(char *p) { } -00293 void Module::OnRehash() { } -00294 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { } -00295 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; } -00296 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; } -00297 Version Module::GetVersion() { return Version(1,0,0,0); } -00298 void Module::OnOper(userrec* user) { }; -00299 void Module::OnInfo(userrec* user) { }; -00300 void Module::OnWhois(userrec* source, userrec* dest) { }; -00301 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; }; -00302 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; }; -00303 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; }; -00304 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; }; -00305 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; } -00306 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; } -00307 -00308 -00309 // server is a wrapper class that provides methods to all of the C-style -00310 // exports in the core -00311 // -00312 -00313 Server::Server() -00314 { -00315 } -00316 -00317 Server::~Server() -00318 { -00319 } -00320 -00321 void Server::SendOpers(std::string s) -00322 { -00323 WriteOpers("%s",s.c_str()); -00324 } -00325 -00326 bool Server::MatchText(std::string sliteral, std::string spattern) -00327 { -00328 char literal[MAXBUF],pattern[MAXBUF]; -00329 strncpy(literal,sliteral.c_str(),MAXBUF); -00330 strncpy(pattern,spattern.c_str(),MAXBUF); -00331 return match(literal,pattern); -00332 } +00178 +00179 extern user_hash clientlist; +00180 extern chan_hash chanlist; +00181 extern user_hash whowas; +00182 extern command_table cmdlist; +00183 extern file_cache MOTD; +00184 extern file_cache RULES; +00185 extern address_cache IP; +00186 +00187 +00188 // class type for holding an extended mode character - internal to core +00189 +00190 class ExtMode : public classbase +00191 { +00192 public: +00193 char modechar; +00194 int type; +00195 int params_when_on; +00196 int params_when_off; +00197 bool needsoper; +00198 bool list; +00199 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) { }; +00200 }; +00201 +00202 typedef std::vector<ExtMode> ExtModeList; +00203 typedef ExtModeList::iterator ExtModeListIter; +00204 +00205 +00206 ExtModeList EMode; +00207 +00208 // returns true if an extended mode character is in use +00209 bool ModeDefined(char modechar, int type) +00210 { +00211 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); +00212 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00213 { +00214 if ((i->modechar == modechar) && (i->type == type)) +00215 { +00216 return true; +00217 } +00218 } +00219 return false; +00220 } +00221 +00222 bool ModeIsListMode(char modechar, int type) +00223 { +00224 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); +00225 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00226 { +00227 if ((i->modechar == modechar) && (i->type == type) && (i->list == true)) +00228 { +00229 return true; +00230 } +00231 } +00232 return false; +00233 } +00234 +00235 bool ModeDefinedOper(char modechar, int type) +00236 { +00237 log(DEBUG,"Size of extmodes vector is %d",EMode.size()); +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; +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 Module::Module() { } +00307 Module::~Module() { } +00308 void Module::OnUserConnect(userrec* user) { } +00309 void Module::OnUserQuit(userrec* user) { } +00310 void Module::OnUserJoin(userrec* user, chanrec* channel) { } +00311 void Module::OnUserPart(userrec* user, chanrec* channel) { } +00312 void Module::OnPacketTransmit(std::string &data, std::string serv) { } +00313 void Module::OnPacketReceive(std::string &data, std::string serv) { } +00314 void Module::OnRehash() { } +00315 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { } +00316 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; } +00317 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; } +00318 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); } +00319 void Module::OnOper(userrec* user) { }; +00320 void Module::OnInfo(userrec* user) { }; +00321 void Module::OnWhois(userrec* source, userrec* dest) { }; +00322 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; }; +00323 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; +00324 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; +00325 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; }; +00326 void Module::OnUserPostNick(userrec* user, std::string oldnick) { }; +00327 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; }; +00328 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; } +00329 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; } +00330 void Module::On005Numeric(std::string &output) { }; +00331 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; }; +00332 void Module::OnLoadModule(Module* mod,std::string name) { }; 00333 -00334 void Server::SendToModeMask(std::string modes, int flags, std::string text) -00335 { -00336 WriteMode(modes.c_str(),flags,"%s",text.c_str()); -00337 } +00334 +00335 // server is a wrapper class that provides methods to all of the C-style +00336 // exports in the core +00337 // 00338 -00339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key) +00339 Server::Server() 00340 { -00341 return add_channel(user,cname.c_str(),key.c_str(),true); -00342 } -00343 -00344 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason) -00345 { -00346 return del_channel(user,cname.c_str(),reason.c_str(),false); -00347 } -00348 -00349 chanuserlist Server::GetUsers(chanrec* chan) -00350 { -00351 chanuserlist userl; -00352 userl.clear(); -00353 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) -00354 { -00355 if (i->second) -00356 { -00357 if (has_channel(i->second,chan)) -00358 { -00359 if (isnick(i->second->nick)) -00360 { -00361 userl.push_back(i->second); -00362 } -00363 } -00364 } -00365 } -00366 return userl; -00367 } -00368 void Server::ChangeUserNick(userrec* user, std::string nickname) -00369 { -00370 force_nickchange(user,nickname.c_str()); -00371 } -00372 -00373 void Server::QuitUser(userrec* user, std::string reason) -00374 { -00375 send_network_quit(user->nick,reason.c_str()); -00376 kill_link(user,reason.c_str()); -00377 } -00378 -00379 bool Server::IsUlined(std::string server) -00380 { -00381 return is_uline(server.c_str()); -00382 } -00383 -00384 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user) -00385 { -00386 call_handler(commandname.c_str(),parameters,pcnt,user); -00387 } -00388 -00389 void Server::Log(int level, std::string s) -00390 { -00391 log(level,"%s",s.c_str()); -00392 } -00393 -00394 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams) +00341 } +00342 +00343 Server::~Server() +00344 { +00345 } +00346 +00347 void Server::SendOpers(std::string s) +00348 { +00349 WriteOpers("%s",s.c_str()); +00350 } +00351 +00352 bool Server::MatchText(std::string sliteral, std::string spattern) +00353 { +00354 char literal[MAXBUF],pattern[MAXBUF]; +00355 strlcpy(literal,sliteral.c_str(),MAXBUF); +00356 strlcpy(pattern,spattern.c_str(),MAXBUF); +00357 return match(literal,pattern); +00358 } +00359 +00360 void Server::SendToModeMask(std::string modes, int flags, std::string text) +00361 { +00362 WriteMode(modes.c_str(),flags,"%s",text.c_str()); +00363 } +00364 +00365 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key) +00366 { +00367 return add_channel(user,cname.c_str(),key.c_str(),true); +00368 } +00369 +00370 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason) +00371 { +00372 return del_channel(user,cname.c_str(),reason.c_str(),false); +00373 } +00374 +00375 chanuserlist Server::GetUsers(chanrec* chan) +00376 { +00377 chanuserlist userl; +00378 userl.clear(); +00379 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) +00380 { +00381 if (i->second) +00382 { +00383 if (has_channel(i->second,chan)) +00384 { +00385 if (isnick(i->second->nick)) +00386 { +00387 userl.push_back(i->second); +00388 } +00389 } +00390 } +00391 } +00392 return userl; +00393 } +00394 void Server::ChangeUserNick(userrec* user, std::string nickname) 00395 { -00396 createcommand(cmd,f,flags,minparams); +00396 force_nickchange(user,nickname.c_str()); 00397 } 00398 -00399 void Server::SendMode(char **parameters, int pcnt, userrec *user) +00399 void Server::QuitUser(userrec* user, std::string reason) 00400 { -00401 server_mode(parameters,pcnt,user); -00402 } -00403 -00404 void Server::Send(int Socket, std::string s) -00405 { -00406 Write(Socket,"%s",s.c_str()); -00407 } -00408 -00409 void Server::SendServ(int Socket, std::string s) -00410 { -00411 WriteServ(Socket,"%s",s.c_str()); -00412 } -00413 -00414 void Server::SendFrom(int Socket, userrec* User, std::string s) -00415 { -00416 WriteFrom(Socket,User,"%s",s.c_str()); -00417 } -00418 -00419 void Server::SendTo(userrec* Source, userrec* Dest, std::string s) -00420 { -00421 if (!Source) -00422 { -00423 // if source is NULL, then the message originates from the local server -00424 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str()); -00425 } -00426 else -00427 { -00428 // otherwise it comes from the user specified -00429 WriteTo(Source,Dest,"%s",s.c_str()); -00430 } -00431 } -00432 -00433 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender) -00434 { -00435 if (IncludeSender) -00436 { -00437 WriteChannel(Channel,User,"%s",s.c_str()); -00438 } -00439 else -00440 { -00441 ChanExceptSender(Channel,User,"%s",s.c_str()); -00442 } +00401 send_network_quit(user->nick,reason.c_str()); +00402 kill_link(user,reason.c_str()); +00403 } +00404 +00405 bool Server::IsUlined(std::string server) +00406 { +00407 return is_uline(server.c_str()); +00408 } +00409 +00410 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user) +00411 { +00412 call_handler(commandname.c_str(),parameters,pcnt,user); +00413 } +00414 +00415 void Server::Log(int level, std::string s) +00416 { +00417 log(level,"%s",s.c_str()); +00418 } +00419 +00420 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source) +00421 { +00422 createcommand(cmd,f,flags,minparams,source); +00423 } +00424 +00425 void Server::SendMode(char **parameters, int pcnt, userrec *user) +00426 { +00427 server_mode(parameters,pcnt,user); +00428 } +00429 +00430 void Server::Send(int Socket, std::string s) +00431 { +00432 Write(Socket,"%s",s.c_str()); +00433 } +00434 +00435 void Server::SendServ(int Socket, std::string s) +00436 { +00437 WriteServ(Socket,"%s",s.c_str()); +00438 } +00439 +00440 void Server::SendFrom(int Socket, userrec* User, std::string s) +00441 { +00442 WriteFrom(Socket,User,"%s",s.c_str()); 00443 } 00444 -00445 bool Server::CommonChannels(userrec* u1, userrec* u2) +00445 void Server::SendTo(userrec* Source, userrec* Dest, std::string s) 00446 { -00447 return (common_channels(u1,u2) != 0); -00448 } -00449 -00450 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) -00451 { -00452 if (IncludeSender) +00447 if (!Source) +00448 { +00449 // if source is NULL, then the message originates from the local server +00450 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str()); +00451 } +00452 else 00453 { -00454 WriteCommon(User,"%s",text.c_str()); -00455 } -00456 else -00457 { -00458 WriteCommonExcept(User,"%s",text.c_str()); -00459 } -00460 } -00461 -00462 void Server::SendWallops(userrec* User, std::string text) -00463 { -00464 WriteWallOps(User,false,"%s",text.c_str()); -00465 } -00466 -00467 void Server::ChangeHost(userrec* user, std::string host) -00468 { -00469 ChangeDisplayedHost(user,host.c_str()); -00470 } -00471 -00472 void Server::ChangeGECOS(userrec* user, std::string gecos) -00473 { -00474 ChangeName(user,gecos.c_str()); -00475 } -00476 -00477 bool Server::IsNick(std::string nick) -00478 { -00479 return (isnick(nick.c_str()) != 0); -00480 } -00481 -00482 userrec* Server::FindNick(std::string nick) -00483 { -00484 return Find(nick); -00485 } -00486 -00487 chanrec* Server::FindChannel(std::string channel) -00488 { -00489 return FindChan(channel.c_str()); -00490 } -00491 -00492 std::string Server::ChanMode(userrec* User, chanrec* Chan) -00493 { -00494 return cmode(User,Chan); -00495 } -00496 -00497 bool Server::IsOnChannel(userrec* User, chanrec* Chan) -00498 { -00499 return has_channel(User,Chan); -00500 } -00501 -00502 std::string Server::GetServerName() -00503 { -00504 return getservername(); -00505 } -00506 -00507 std::string Server::GetNetworkName() -00508 { -00509 return getnetworkname(); -00510 } -00511 -00512 Admin Server::GetAdmin() -00513 { -00514 return Admin(getadminname(),getadminemail(),getadminnick()); -00515 } -00516 +00454 // otherwise it comes from the user specified +00455 WriteTo(Source,Dest,"%s",s.c_str()); +00456 } +00457 } +00458 +00459 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender) +00460 { +00461 if (IncludeSender) +00462 { +00463 WriteChannel(Channel,User,"%s",s.c_str()); +00464 } +00465 else +00466 { +00467 ChanExceptSender(Channel,User,"%s",s.c_str()); +00468 } +00469 } +00470 +00471 bool Server::CommonChannels(userrec* u1, userrec* u2) +00472 { +00473 return (common_channels(u1,u2) != 0); +00474 } +00475 +00476 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) +00477 { +00478 if (IncludeSender) +00479 { +00480 WriteCommon(User,"%s",text.c_str()); +00481 } +00482 else +00483 { +00484 WriteCommonExcept(User,"%s",text.c_str()); +00485 } +00486 } +00487 +00488 void Server::SendWallops(userrec* User, std::string text) +00489 { +00490 WriteWallOps(User,false,"%s",text.c_str()); +00491 } +00492 +00493 void Server::ChangeHost(userrec* user, std::string host) +00494 { +00495 ChangeDisplayedHost(user,host.c_str()); +00496 } +00497 +00498 void Server::ChangeGECOS(userrec* user, std::string gecos) +00499 { +00500 ChangeName(user,gecos.c_str()); +00501 } +00502 +00503 bool Server::IsNick(std::string nick) +00504 { +00505 return (isnick(nick.c_str()) != 0); +00506 } +00507 +00508 userrec* Server::FindNick(std::string nick) +00509 { +00510 return Find(nick); +00511 } +00512 +00513 chanrec* Server::FindChannel(std::string channel) +00514 { +00515 return FindChan(channel.c_str()); +00516 } 00517 -00518 -00519 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off) -00520 { -00521 if (type == MT_SERVER) -00522 { -00523 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion"); -00524 return false; -00525 } -00526 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT)) -00527 { -00528 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported"); -00529 return false; -00530 } -00531 if ((params_when_on>1) || (params_when_off>1)) -00532 { -00533 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported"); -00534 return false; -00535 } -00536 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off); -00537 } -00538 -00539 bool Server::AddExtendedListMode(char modechar) -00540 { -00541 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1); -00542 if (res) -00543 ModeMakeList(modechar); -00544 return res; -00545 } -00546 -00547 int Server::CountUsers(chanrec* c) -00548 { -00549 return usercount(c); -00550 } -00551 -00552 -00553 ConfigReader::ConfigReader() -00554 { -00555 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); -00556 this->readerror = LoadConf(CONFIG_FILE,this->cache); -00557 if (!this->readerror) -00558 this->error = CONF_FILE_NOT_FOUND; -00559 } -00560 -00561 -00562 ConfigReader::~ConfigReader() -00563 { -00564 if (this->cache) -00565 delete this->cache; -00566 } -00567 -00568 -00569 ConfigReader::ConfigReader(std::string filename) -00570 { -00571 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); -00572 this->readerror = LoadConf(filename.c_str(),this->cache); -00573 if (!this->readerror) -00574 this->error = CONF_FILE_NOT_FOUND; -00575 }; -00576 -00577 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index) -00578 { -00579 char val[MAXBUF]; -00580 char t[MAXBUF]; -00581 char n[MAXBUF]; -00582 strncpy(t,tag.c_str(),MAXBUF); -00583 strncpy(n,name.c_str(),MAXBUF); -00584 int res = ReadConf(cache,t,n,index,val); -00585 if (!res) -00586 { -00587 this->error = CONF_VALUE_NOT_FOUND; -00588 return ""; -00589 } -00590 return std::string(val); -00591 } -00592 -00593 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index) -00594 { -00595 char val[MAXBUF]; -00596 char t[MAXBUF]; -00597 char n[MAXBUF]; -00598 strncpy(t,tag.c_str(),MAXBUF); -00599 strncpy(n,name.c_str(),MAXBUF); -00600 int res = ReadConf(cache,t,n,index,val); -00601 if (!res) -00602 { -00603 this->error = CONF_VALUE_NOT_FOUND; -00604 return false; -00605 } -00606 std::string s = val; -00607 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1")); -00608 } -00609 -00610 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned) -00611 { -00612 char val[MAXBUF]; -00613 char t[MAXBUF]; -00614 char n[MAXBUF]; -00615 strncpy(t,tag.c_str(),MAXBUF); -00616 strncpy(n,name.c_str(),MAXBUF); -00617 int res = ReadConf(cache,t,n,index,val); -00618 if (!res) -00619 { -00620 this->error = CONF_VALUE_NOT_FOUND; -00621 return 0; -00622 } -00623 for (int i = 0; i < strlen(val); i++) -00624 { -00625 if (!isdigit(val[i])) -00626 { -00627 this->error = CONF_NOT_A_NUMBER; -00628 return 0; -00629 } -00630 } -00631 if ((needs_unsigned) && (atoi(val)<0)) +00518 std::string Server::ChanMode(userrec* User, chanrec* Chan) +00519 { +00520 return cmode(User,Chan); +00521 } +00522 +00523 bool Server::IsOnChannel(userrec* User, chanrec* Chan) +00524 { +00525 return has_channel(User,Chan); +00526 } +00527 +00528 std::string Server::GetServerName() +00529 { +00530 return getservername(); +00531 } +00532 +00533 std::string Server::GetNetworkName() +00534 { +00535 return getnetworkname(); +00536 } +00537 +00538 Admin Server::GetAdmin() +00539 { +00540 return Admin(getadminname(),getadminemail(),getadminnick()); +00541 } +00542 +00543 +00544 +00545 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off) +00546 { +00547 if (type == MT_SERVER) +00548 { +00549 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion"); +00550 return false; +00551 } +00552 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT)) +00553 { +00554 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported"); +00555 return false; +00556 } +00557 if ((params_when_on>1) || (params_when_off>1)) +00558 { +00559 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported"); +00560 return false; +00561 } +00562 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off); +00563 } +00564 +00565 bool Server::AddExtendedListMode(char modechar) +00566 { +00567 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1); +00568 if (res) +00569 ModeMakeList(modechar); +00570 return res; +00571 } +00572 +00573 int Server::CountUsers(chanrec* c) +00574 { +00575 return usercount(c); +00576 } +00577 +00578 +00579 ConfigReader::ConfigReader() +00580 { +00581 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); +00582 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); +00583 this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog); +00584 if (!this->readerror) +00585 this->error = CONF_FILE_NOT_FOUND; +00586 } +00587 +00588 +00589 ConfigReader::~ConfigReader() +00590 { +00591 if (this->cache) +00592 delete this->cache; +00593 if (this->errorlog) +00594 delete this->errorlog; +00595 } +00596 +00597 +00598 ConfigReader::ConfigReader(std::string filename) +00599 { +00600 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); +00601 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); +00602 this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog); +00603 if (!this->readerror) +00604 this->error = CONF_FILE_NOT_FOUND; +00605 }; +00606 +00607 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index) +00608 { +00609 char val[MAXBUF]; +00610 char t[MAXBUF]; +00611 char n[MAXBUF]; +00612 strlcpy(t,tag.c_str(),MAXBUF); +00613 strlcpy(n,name.c_str(),MAXBUF); +00614 int res = ReadConf(cache,t,n,index,val); +00615 if (!res) +00616 { +00617 this->error = CONF_VALUE_NOT_FOUND; +00618 return ""; +00619 } +00620 return std::string(val); +00621 } +00622 +00623 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index) +00624 { +00625 char val[MAXBUF]; +00626 char t[MAXBUF]; +00627 char n[MAXBUF]; +00628 strlcpy(t,tag.c_str(),MAXBUF); +00629 strlcpy(n,name.c_str(),MAXBUF); +00630 int res = ReadConf(cache,t,n,index,val); +00631 if (!res) 00632 { -00633 this->error = CONF_NOT_UNSIGNED; -00634 return 0; +00633 this->error = CONF_VALUE_NOT_FOUND; +00634 return false; 00635 } -00636 return atoi(val); -00637 } -00638 -00639 long ConfigReader::GetError() -00640 { -00641 long olderr = this->error; -00642 this->error = 0; -00643 return olderr; -00644 } -00645 -00646 -00647 int ConfigReader::Enumerate(std::string tag) -00648 { -00649 return EnumConf(cache,tag.c_str()); -00650 } -00651 -00652 int ConfigReader::EnumerateValues(std::string tag, int index) -00653 { -00654 return EnumValues(cache, tag.c_str(), index); -00655 } -00656 -00657 bool ConfigReader::Verify() -00658 { -00659 return this->readerror; -00660 } -00661 -00662 -00663 FileReader::FileReader(std::string filename) -00664 { -00665 file_cache c; -00666 readfile(c,filename.c_str()); -00667 this->fc = c; -00668 } -00669 -00670 FileReader::FileReader() -00671 { -00672 } -00673 -00674 void FileReader::LoadFile(std::string filename) -00675 { -00676 file_cache c; -00677 readfile(c,filename.c_str()); -00678 this->fc = c; -00679 } -00680 -00681 -00682 FileReader::~FileReader() -00683 { -00684 } -00685 -00686 bool FileReader::Exists() -00687 { -00688 if (fc.size() == 0) -00689 { -00690 return(false); -00691 } -00692 else -00693 { -00694 return(true); -00695 } -00696 } -00697 -00698 std::string FileReader::GetLine(int x) -00699 { -00700 if ((x<0) || (x>fc.size())) -00701 return ""; -00702 return fc[x]; -00703 } -00704 -00705 int FileReader::FileSize() -00706 { -00707 return fc.size(); -00708 } -00709 -00710 -00711 std::vector<Module*> modules(255); -00712 std::vector<ircd_module*> factory(255); +00636 std::string s = val; +00637 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1")); +00638 } +00639 +00640 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned) +00641 { +00642 char val[MAXBUF]; +00643 char t[MAXBUF]; +00644 char n[MAXBUF]; +00645 strlcpy(t,tag.c_str(),MAXBUF); +00646 strlcpy(n,name.c_str(),MAXBUF); +00647 int res = ReadConf(cache,t,n,index,val); +00648 if (!res) +00649 { +00650 this->error = CONF_VALUE_NOT_FOUND; +00651 return 0; +00652 } +00653 for (int i = 0; i < strlen(val); i++) +00654 { +00655 if (!isdigit(val[i])) +00656 { +00657 this->error = CONF_NOT_A_NUMBER; +00658 return 0; +00659 } +00660 } +00661 if ((needs_unsigned) && (atoi(val)<0)) +00662 { +00663 this->error = CONF_NOT_UNSIGNED; +00664 return 0; +00665 } +00666 return atoi(val); +00667 } +00668 +00669 long ConfigReader::GetError() +00670 { +00671 long olderr = this->error; +00672 this->error = 0; +00673 return olderr; +00674 } +00675 +00676 void ConfigReader::DumpErrors(bool bail, userrec* user) +00677 { +00678 if (bail) +00679 { +00680 printf("There were errors in your configuration:\n%s",errorlog->str().c_str()); +00681 exit(0); +00682 } +00683 else +00684 { +00685 char dataline[1024]; +00686 if (user) +00687 { +00688 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick); +00689 while (!errorlog->eof()) +00690 { +00691 errorlog->getline(dataline,1024); +00692 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline); +00693 } +00694 } +00695 else +00696 { +00697 WriteOpers("There were errors in the configuration file:",user->nick); +00698 while (!errorlog->eof()) +00699 { +00700 errorlog->getline(dataline,1024); +00701 WriteOpers(dataline); +00702 } +00703 } +00704 return; +00705 } +00706 } +00707 +00708 +00709 int ConfigReader::Enumerate(std::string tag) +00710 { +00711 return EnumConf(cache,tag.c_str()); +00712 } 00713 -00714 int MODCOUNT = -1; -00715 -00716 -
Generated on Sat May 1 20:57:47 2004 for InspIRCd by +00714 int ConfigReader::EnumerateValues(std::string tag, int index) +00715 { +00716 return EnumValues(cache, tag.c_str(), index); +00717 } +00718 +00719 bool ConfigReader::Verify() +00720 { +00721 return this->readerror; +00722 } +00723 +00724 +00725 FileReader::FileReader(std::string filename) +00726 { +00727 file_cache c; +00728 readfile(c,filename.c_str()); +00729 this->fc = c; +00730 } +00731 +00732 FileReader::FileReader() +00733 { +00734 } +00735 +00736 void FileReader::LoadFile(std::string filename) +00737 { +00738 file_cache c; +00739 readfile(c,filename.c_str()); +00740 this->fc = c; +00741 } +00742 +00743 +00744 FileReader::~FileReader() +00745 { +00746 } +00747 +00748 bool FileReader::Exists() +00749 { +00750 if (fc.size() == 0) +00751 { +00752 return(false); +00753 } +00754 else +00755 { +00756 return(true); +00757 } +00758 } +00759 +00760 std::string FileReader::GetLine(int x) +00761 { +00762 if ((x<0) || (x>fc.size())) +00763 return ""; +00764 return fc[x]; +00765 } +00766 +00767 int FileReader::FileSize() +00768 { +00769 return fc.size(); +00770 } +00771 +00772 +00773 std::vector<Module*> modules(255); +00774 std::vector<ircd_module*> factory(255); +00775 +00776 int MODCOUNT = -1; +00777 +00778 +