modules.cpp Source File

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;
-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         };
+
+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 
+00055 #ifdef GCC3
+00056 #define nspace __gnu_cxx
+00057 #else
+00058 #define nspace std
+00059 #endif
+00060 
+00061 using namespace std;
+00062 
+00063 extern int MODCOUNT;
+00064 extern vector<Module*> modules;
+00065 extern vector<ircd_module*> factory;
+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 boundPortCount;
+00095 extern int portCount;
+00096 extern int UDPportCount;
+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 serverrec* me[32];
 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         }
-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;
-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;
+00105 extern FILE *log_file;
+00106 
+00107 
+00108 namespace nspace
+00109 {
+00110         template<> struct nspace::hash<in_addr>
+00111         {
+00112                 size_t operator()(const struct in_addr &a) const
+00113                 {
+00114                         size_t q;
+00115                         memcpy(&q,&a,sizeof(size_t));
+00116                         return q;
+00117                 }
+00118         };
+00119 
+00120         template<> struct nspace::hash<string>
+00121         {
+00122                 size_t operator()(const string &s) const
+00123                 {
+00124                         char a[MAXBUF];
+00125                         static struct hash<const char *> strhash;
+00126                         strlcpy(a,s.c_str(),MAXBUF);
+00127                         strlower(a);
+00128                         return strhash(a);
+00129                 }
+00130         };
+00131 }       
+00132 
+00133 
+00134 struct StrHashComp
+00135 {
+00136 
+00137         bool operator()(const string& s1, const string& s2) const
+00138         {
+00139                 char a[MAXBUF],b[MAXBUF];
+00140                 strlcpy(a,s1.c_str(),MAXBUF);
+00141                 strlcpy(b,s2.c_str(),MAXBUF);
+00142                 return (strcasecmp(a,b) == 0);
+00143         }
+00144 
+00145 };
+00146 
+00147 struct InAddr_HashComp
+00148 {
+00149 
+00150         bool operator()(const in_addr &s1, const in_addr &s2) const
+00151         {
+00152                 size_t q;
+00153                 size_t p;
+00154                 
+00155                 memcpy(&q,&s1,sizeof(size_t));
+00156                 memcpy(&p,&s2,sizeof(size_t));
+00157                 
+00158                 return (q == p);
+00159         }
+00160 
+00161 };
 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 };                                     
+00164 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
+00165 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
+00166 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
+00167 typedef std::deque<command_t> command_table;
+00168 
+00169 
+00170 extern user_hash clientlist;
+00171 extern chan_hash chanlist;
+00172 extern user_hash whowas;
+00173 extern command_table cmdlist;
+00174 extern file_cache MOTD;
+00175 extern file_cache RULES;
+00176 extern address_cache IP;
 00177 
-00178 typedef std::vector<ExtMode> ExtModeList;
-00179 typedef ExtModeList::iterator ExtModeListIter;
+00178 
+00179 // class type for holding an extended mode character - internal to core
 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 }
+00181 class ExtMode : public classbase
+00182 {
+00183 public:
+00184         char modechar;
+00185         int type;
+00186         int params_when_on;
+00187         int params_when_off;
+00188         bool needsoper;
+00189         bool list;
+00190         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) { };
+00191 };                                     
+00192 
+00193 typedef std::vector<ExtMode> ExtModeList;
+00194 typedef ExtModeList::iterator ExtModeListIter;
+00195 
+00196 
+00197 ExtModeList EMode;
 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))
+00199 // returns true if an extended mode character is in use
+00200 bool ModeDefined(char modechar, int type)
+00201 {
+00202         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
+00203         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00204         {
+00205                 if ((i->modechar == modechar) && (i->type == type))
 00206                 {
 00207                         return true;
 00208                 }
@@ -218,513 +217,562 @@
 00210         return false;
 00211 }
 00212 
-00213 bool ModeDefinedOper(char modechar, int type)
+00213 bool ModeIsListMode(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++)
+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 &params) { 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 }
+00218                 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
+00219                 {
+00220                         return true;
+00221                 }
+00222         }
+00223         return false;
+00224 }
+00225 
+00226 bool ModeDefinedOper(char modechar, int type)
+00227 {
+00228         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
+00229         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00230         {
+00231                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
+00232                 {
+00233                         return true;
+00234                 }
+00235         }
+00236         return false;
+00237 }
+00238 
+00239 // returns number of parameters for a custom mode when it is switched on
+00240 int ModeDefinedOn(char modechar, int type)
+00241 {
+00242         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00243         {
+00244                 if ((i->modechar == modechar) && (i->type == type))
+00245                 {
+00246                         return i->params_when_on;
+00247                 }
+00248         }
+00249         return 0;
+00250 }
+00251 
+00252 // returns number of parameters for a custom mode when it is switched on
+00253 int ModeDefinedOff(char modechar, int type)
+00254 {
+00255         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00256         {
+00257                 if ((i->modechar == modechar) && (i->type == type))
+00258                 {
+00259                         return i->params_when_off;
+00260                 }
+00261         }
+00262         return 0;
+00263 }
+00264 
+00265 // returns true if an extended mode character is in use
+00266 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
+00267 {
+00268         if (ModeDefined(modechar,type)) {
+00269                 return false;
+00270         }
+00271         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
+00272         return true;
+00273 }
+00274 
+00275 // turns a mode into a listmode
+00276 void ModeMakeList(char modechar)
+00277 {
+00278         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00279         {
+00280                 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
+00281                 {
+00282                         i->list = true;
+00283                         return;
+00284                 }
+00285         }
+00286         return;
+00287 }
+00288 
+00289 // version is a simple class for holding a modules version number
+00290 
+00291 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+00292 
+00293 // admin is a simple class for holding a server's administrative info
+00294 
+00295 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
+00296 
+00297 Module::Module() { }
+00298 Module::~Module() { }
+00299 void Module::OnUserConnect(userrec* user) { }
+00300 void Module::OnUserQuit(userrec* user) { }
+00301 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
+00302 void Module::OnUserPart(userrec* user, chanrec* channel) { }
+00303 void Module::OnPacketTransmit(char *p) { }
+00304 void Module::OnPacketReceive(char *p) { }
+00305 void Module::OnRehash() { }
+00306 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
+00307 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
+00308 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { return false; }
+00309 Version Module::GetVersion() { return Version(1,0,0,0); }
+00310 void Module::OnOper(userrec* user) { };
+00311 void Module::OnInfo(userrec* user) { };
+00312 void Module::OnWhois(userrec* source, userrec* dest) { };
+00313 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
+00314 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00315 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00316 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
+00317 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
+00318 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
+00319 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
 00320 
-00321 void Server::SendOpers(std::string s)
-00322 {
-00323         WriteOpers("%s",s.c_str());
-00324 }
+00321 
+00322 // server is a wrapper class that provides methods to all of the C-style
+00323 // exports in the core
+00324 //
 00325 
-00326 bool Server::MatchText(std::string sliteral, std::string spattern)
+00326 Server::Server()
 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);
+00328 }
+00329 
+00330 Server::~Server()
+00331 {
 00332 }
 00333 
-00334 void Server::SendToModeMask(std::string modes, int flags, std::string text)
+00334 void Server::SendOpers(std::string s)
 00335 {
-00336         WriteMode(modes.c_str(),flags,"%s",text.c_str());
+00336         WriteOpers("%s",s.c_str());
 00337 }
 00338 
-00339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
+00339 bool Server::MatchText(std::string sliteral, std::string spattern)
 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)
-00395 {
-00396         createcommand(cmd,f,flags,minparams);
-00397 }
-00398 
-00399 void Server::SendMode(char **parameters, int pcnt, userrec *user)
-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());
+00341         char literal[MAXBUF],pattern[MAXBUF];
+00342         strlcpy(literal,sliteral.c_str(),MAXBUF);
+00343         strlcpy(pattern,spattern.c_str(),MAXBUF);
+00344         return match(literal,pattern);
+00345 }
+00346 
+00347 void Server::SendToModeMask(std::string modes, int flags, std::string text)
+00348 {
+00349         WriteMode(modes.c_str(),flags,"%s",text.c_str());
+00350 }
+00351 
+00352 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
+00353 {
+00354         return add_channel(user,cname.c_str(),key.c_str(),true);
+00355 }
+00356 
+00357 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
+00358 {
+00359         return del_channel(user,cname.c_str(),reason.c_str(),false);
+00360 }
+00361 
+00362 chanuserlist Server::GetUsers(chanrec* chan)
+00363 {
+00364         chanuserlist userl;
+00365         userl.clear();
+00366         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
+00367         {
+00368                 if (i->second)
+00369                 {
+00370                         if (has_channel(i->second,chan))
+00371                         {
+00372                                 if (isnick(i->second->nick))
+00373                                 {
+00374                                         userl.push_back(i->second);
+00375                                 }
+00376                         }
+00377                 }
+00378         }
+00379         return userl;
+00380 }
+00381 void Server::ChangeUserNick(userrec* user, std::string nickname)
+00382 {
+00383         force_nickchange(user,nickname.c_str());
+00384 }
+00385 
+00386 void Server::QuitUser(userrec* user, std::string reason)
+00387 {
+00388         send_network_quit(user->nick,reason.c_str());
+00389         kill_link(user,reason.c_str());
+00390 }
+00391 
+00392 bool Server::IsUlined(std::string server)
+00393 {
+00394         return is_uline(server.c_str());
+00395 }
+00396 
+00397 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+00398 {
+00399         call_handler(commandname.c_str(),parameters,pcnt,user);
+00400 }
+00401 
+00402 void Server::Log(int level, std::string s)
+00403 {
+00404         log(level,"%s",s.c_str());
+00405 }
+00406 
+00407 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
+00408 {
+00409         createcommand(cmd,f,flags,minparams);
+00410 }
+00411 
+00412 void Server::SendMode(char **parameters, int pcnt, userrec *user)
+00413 {
+00414         server_mode(parameters,pcnt,user);
+00415 }
+00416 
+00417 void Server::Send(int Socket, std::string s)
+00418 {
+00419         Write(Socket,"%s",s.c_str());
+00420 }
+00421 
+00422 void Server::SendServ(int Socket, std::string s)
+00423 {
+00424         WriteServ(Socket,"%s",s.c_str());
+00425 }
+00426 
+00427 void Server::SendFrom(int Socket, userrec* User, std::string s)
+00428 {
+00429         WriteFrom(Socket,User,"%s",s.c_str());
+00430 }
+00431 
+00432 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
+00433 {
+00434         if (!Source)
+00435         {
+00436                 // if source is NULL, then the message originates from the local server
+00437                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
 00438         }
 00439         else
 00440         {
-00441                 ChanExceptSender(Channel,User,"%s",s.c_str());
-00442         }
-00443 }
-00444 
-00445 bool Server::CommonChannels(userrec* u1, userrec* u2)
-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)
+00441                 // otherwise it comes from the user specified
+00442                 WriteTo(Source,Dest,"%s",s.c_str());
+00443         }
+00444 }
+00445 
+00446 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
+00447 {
+00448         if (IncludeSender)
+00449         {
+00450                 WriteChannel(Channel,User,"%s",s.c_str());
+00451         }
+00452         else
 00453         {
-00454                 WriteCommon(User,"%s",text.c_str());
+00454                 ChanExceptSender(Channel,User,"%s",s.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 
-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);
+00456 }
+00457 
+00458 bool Server::CommonChannels(userrec* u1, userrec* u2)
+00459 {
+00460         return (common_channels(u1,u2) != 0);
+00461 }
+00462 
+00463 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
+00464 {
+00465         if (IncludeSender)
+00466         {
+00467                 WriteCommon(User,"%s",text.c_str());
+00468         }
+00469         else
+00470         {
+00471                 WriteCommonExcept(User,"%s",text.c_str());
+00472         }
+00473 }
+00474 
+00475 void Server::SendWallops(userrec* User, std::string text)
+00476 {
+00477         WriteWallOps(User,false,"%s",text.c_str());
+00478 }
+00479 
+00480 void Server::ChangeHost(userrec* user, std::string host)
+00481 {
+00482         ChangeDisplayedHost(user,host.c_str());
+00483 }
+00484 
+00485 void Server::ChangeGECOS(userrec* user, std::string gecos)
+00486 {
+00487         ChangeName(user,gecos.c_str());
+00488 }
+00489 
+00490 bool Server::IsNick(std::string nick)
+00491 {
+00492         return (isnick(nick.c_str()) != 0);
+00493 }
+00494 
+00495 userrec* Server::FindNick(std::string nick)
+00496 {
+00497         return Find(nick);
+00498 }
+00499 
+00500 chanrec* Server::FindChannel(std::string channel)
+00501 {
+00502         return FindChan(channel.c_str());
+00503 }
+00504 
+00505 std::string Server::ChanMode(userrec* User, chanrec* Chan)
+00506 {
+00507         return cmode(User,Chan);
+00508 }
+00509 
+00510 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
+00511 {
+00512         return has_channel(User,Chan);
+00513 }
+00514 
+00515 std::string Server::GetServerName()
+00516 {
+00517         return getservername();
+00518 }
+00519 
+00520 std::string Server::GetNetworkName()
+00521 {
+00522         return getnetworkname();
+00523 }
+00524 
+00525 Admin Server::GetAdmin()
+00526 {
+00527         return Admin(getadminname(),getadminemail(),getadminnick());
+00528 }
+00529 
+00530 
+00531 
+00532 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
+00533 {
+00534         if (type == MT_SERVER)
+00535         {
+00536                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
+00537                 return false;
+00538         }
+00539         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
+00540         {
+00541                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
+00542                 return false;
+00543         }
+00544         if ((params_when_on>1) || (params_when_off>1))
+00545         {
+00546                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
+00547                 return false;
+00548         }
+00549         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
 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"));
+00552 bool Server::AddExtendedListMode(char modechar)
+00553 {
+00554         bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
+00555         if (res)
+00556                 ModeMakeList(modechar);
+00557         return res;
+00558 }
+00559 
+00560 int Server::CountUsers(chanrec* c)
+00561 {
+00562         return usercount(c);
+00563 }
+00564 
+00565 
+00566 ConfigReader::ConfigReader()
+00567 {
+00568         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00569         this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00570         this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog);
+00571         if (!this->readerror)
+00572                 this->error = CONF_FILE_NOT_FOUND;
+00573 }
+00574 
+00575 
+00576 ConfigReader::~ConfigReader()
+00577 {
+00578         if (this->cache)
+00579                 delete this->cache;
+00580         if (this->errorlog)
+00581                 delete this->errorlog;
+00582 }
+00583 
+00584 
+00585 ConfigReader::ConfigReader(std::string filename)
+00586 {
+00587         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00588         this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00589         this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog);
+00590         if (!this->readerror)
+00591                 this->error = CONF_FILE_NOT_FOUND;
+00592 };
+00593 
+00594 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
+00595 {
+00596         char val[MAXBUF];
+00597         char t[MAXBUF];
+00598         char n[MAXBUF];
+00599         strlcpy(t,tag.c_str(),MAXBUF);
+00600         strlcpy(n,name.c_str(),MAXBUF);
+00601         int res = ReadConf(cache,t,n,index,val);
+00602         if (!res)
+00603         {
+00604                 this->error = CONF_VALUE_NOT_FOUND;
+00605                 return "";
+00606         }
+00607         return std::string(val);
 00608 }
 00609 
-00610 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
+00610 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
 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);
+00615         strlcpy(t,tag.c_str(),MAXBUF);
+00616         strlcpy(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;
+00620                 this->error = CONF_VALUE_NOT_FOUND;
+00621                 return false;
 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))
-00632         {
-00633                 this->error = CONF_NOT_UNSIGNED;
-00634                 return 0;
-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 
+00623         std::string s = val;
+00624         return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
+00625 }
+00626 
+00627 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
+00628 {
+00629         char val[MAXBUF];
+00630         char t[MAXBUF];
+00631         char n[MAXBUF];
+00632         strlcpy(t,tag.c_str(),MAXBUF);
+00633         strlcpy(n,name.c_str(),MAXBUF);
+00634         int res = ReadConf(cache,t,n,index,val);
+00635         if (!res)
+00636         {
+00637                 this->error = CONF_VALUE_NOT_FOUND;
+00638                 return 0;
+00639         }
+00640         for (int i = 0; i < strlen(val); i++)
+00641         {
+00642                 if (!isdigit(val[i]))
+00643                 {
+00644                         this->error = CONF_NOT_A_NUMBER;
+00645                         return 0;
+00646                 }
+00647         }
+00648         if ((needs_unsigned) && (atoi(val)<0))
+00649         {
+00650                 this->error = CONF_NOT_UNSIGNED;
+00651                 return 0;
+00652         }
+00653         return atoi(val);
+00654 }
+00655 
+00656 long ConfigReader::GetError()
+00657 {
+00658         long olderr = this->error;
+00659         this->error = 0;
+00660         return olderr;
+00661 }
 00662 
-00663 FileReader::FileReader(std::string filename)
+00663 void ConfigReader::DumpErrors(bool bail, userrec* user)
 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 
+00665         if (bail)
+00666         {
+00667                 printf("There were errors in your configuration:\n%s",errorlog->str().c_str());
+00668                 exit(0);
+00669         }
+00670         else
+00671         {
+00672                 char dataline[1024];
+00673                 if (user)
+00674                 {
+00675                         WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
+00676                         while (!errorlog->eof())
+00677                         {
+00678                                 errorlog->getline(dataline,1024);
+00679                                 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
+00680                         }
+00681                 }
+00682                 else
+00683                 {
+00684                         WriteOpers("There were errors in the configuration file:",user->nick);
+00685                         while (!errorlog->eof())
+00686                         {
+00687                                 errorlog->getline(dataline,1024);
+00688                                 WriteOpers(dataline);
+00689                         }
+00690                 }
+00691                 return;
+00692         }
+00693 }
+00694 
+00695 
+00696 int ConfigReader::Enumerate(std::string tag)
+00697 {
+00698         return EnumConf(cache,tag.c_str());
+00699 }
+00700 
+00701 int ConfigReader::EnumerateValues(std::string tag, int index)
+00702 {
+00703         return EnumValues(cache, tag.c_str(), index);
+00704 }
+00705 
+00706 bool ConfigReader::Verify()
+00707 {
+00708         return this->readerror;
+00709 }
 00710 
-00711 std::vector<Module*> modules(255);
-00712 std::vector<ircd_module*> factory(255);
-00713 
-00714 int MODCOUNT  = -1;
-00715 
-00716 
-
Generated on Sun May 2 00:09:18 2004 for InspIRCd by
+00711 
+00712 FileReader::FileReader(std::string filename)
+00713 {
+00714         file_cache c;
+00715         readfile(c,filename.c_str());
+00716         this->fc = c;
+00717 }
+00718 
+00719 FileReader::FileReader()
+00720 {
+00721 }
+00722 
+00723 void FileReader::LoadFile(std::string filename)
+00724 {
+00725         file_cache c;
+00726         readfile(c,filename.c_str());
+00727         this->fc = c;
+00728 }
+00729 
+00730 
+00731 FileReader::~FileReader()
+00732 {
+00733 }
+00734 
+00735 bool FileReader::Exists()
+00736 {
+00737         if (fc.size() == 0)
+00738         {
+00739                 return(false);
+00740         }
+00741         else
+00742         {
+00743                 return(true);
+00744         }
+00745 }
+00746 
+00747 std::string FileReader::GetLine(int x)
+00748 {
+00749         if ((x<0) || (x>fc.size()))
+00750                 return "";
+00751         return fc[x];
+00752 }
+00753 
+00754 int FileReader::FileSize()
+00755 {
+00756         return fc.size();
+00757 }
+00758 
+00759 
+00760 std::vector<Module*> modules(255);
+00761 std::vector<ircd_module*> factory(255);
+00762 
+00763 int MODCOUNT  = -1;
+00764 
+00765 
+