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