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