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