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