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

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