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