X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules.cpp;h=7e932ed72ba9f508246ba5f34fdbf116df74f4b1;hb=8d066e557eeabaea40634dec8d6f5cd4d39cfe60;hp=22047ce811e159276a2d37d013e1637139ff234c;hpb=932e8d13f81c7c94a89dc3702f6d45bc185f5dcf;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules.cpp b/src/modules.cpp
index 22047ce81..7e932ed72 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -26,26 +26,20 @@
 
 #include <iostream>
 #include "inspircd.h"
-#include "xline.h"
-#include "socket.h"
-#include "socketengine.h"
-#include "command_parse.h"
 #include "exitcodes.h"
 
 #ifndef _WIN32
 	#include <dirent.h>
 #endif
 
-static std::vector<dynamic_reference_base*>* dynrefs = NULL;
-static bool dynref_init_complete = false;
+static insp::intrusive_list<dynamic_reference_base>* dynrefs = NULL;
 
 void dynamic_reference_base::reset_all()
 {
-	dynref_init_complete = true;
 	if (!dynrefs)
 		return;
-	for(unsigned int i = 0; i < dynrefs->size(); i++)
-		(*dynrefs)[i]->resolve();
+	for (insp::intrusive_list<dynamic_reference_base>::iterator i = dynrefs->begin(); i != dynrefs->end(); ++i)
+		(*i)->resolve();
 }
 
 // Version is a simple class for holding a modules version number
@@ -92,14 +86,14 @@ void		Module::OnUserPart(Membership*, std::string&, CUList&) { DetachEvent(I_OnU
 void		Module::OnPreRehash(User*, const std::string&) { DetachEvent(I_OnPreRehash); }
 void		Module::OnModuleRehash(User*, const std::string&) { DetachEvent(I_OnModuleRehash); }
 ModResult	Module::OnUserPreJoin(LocalUser*, Channel*, const std::string&, std::string&, const std::string&) { DetachEvent(I_OnUserPreJoin); return MOD_RES_PASSTHRU; }
-void		Module::OnMode(User*, User*, Channel*, const std::vector<std::string>&, const std::vector<TranslateType>&) { DetachEvent(I_OnMode); }
+void		Module::OnMode(User*, User*, Channel*, const Modes::ChangeList&, ModeParser::ModeProcessFlag, const std::string&) { DetachEvent(I_OnMode); }
 void		Module::OnOper(User*, const std::string&) { DetachEvent(I_OnOper); }
 void		Module::OnPostOper(User*, const std::string&, const std::string &) { DetachEvent(I_OnPostOper); }
 void		Module::OnInfo(User*) { DetachEvent(I_OnInfo); }
 void		Module::OnWhois(User*, User*) { DetachEvent(I_OnWhois); }
 ModResult	Module::OnUserPreInvite(User*, User*, Channel*, time_t) { DetachEvent(I_OnUserPreInvite); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnUserPreMessage(User*, void*, int, std::string&, char, CUList&, MessageType) { DetachEvent(I_OnUserPreMessage); return MOD_RES_PASSTHRU; }
-ModResult	Module::OnUserPreNick(User*, const std::string&) { DetachEvent(I_OnUserPreNick); return MOD_RES_PASSTHRU; }
+ModResult	Module::OnUserPreNick(LocalUser*, const std::string&) { DetachEvent(I_OnUserPreNick); return MOD_RES_PASSTHRU; }
 void		Module::OnUserPostNick(User*, const std::string&) { DetachEvent(I_OnUserPostNick); }
 ModResult	Module::OnPreMode(User*, User*, Channel*, const std::vector<std::string>&) { DetachEvent(I_OnPreMode); return MOD_RES_PASSTHRU; }
 void		Module::On005Numeric(std::map<std::string, std::string>&) { DetachEvent(I_On005Numeric); }
@@ -114,7 +108,7 @@ ModResult	Module::OnCheckReady(LocalUser*) { DetachEvent(I_OnCheckReady); return
 ModResult	Module::OnUserRegister(LocalUser*) { DetachEvent(I_OnUserRegister); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnUserPreKick(User*, Membership*, const std::string&) { DetachEvent(I_OnUserPreKick); return MOD_RES_PASSTHRU; }
 void		Module::OnUserKick(User*, Membership*, const std::string&, CUList&) { DetachEvent(I_OnUserKick); }
-ModResult	Module::OnRawMode(User*, Channel*, const char, const std::string &, bool, int) { DetachEvent(I_OnRawMode); return MOD_RES_PASSTHRU; }
+ModResult	Module::OnRawMode(User*, Channel*, ModeHandler*, const std::string&, bool) { DetachEvent(I_OnRawMode); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnCheckInvite(User*, Channel*) { DetachEvent(I_OnCheckInvite); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnCheckKey(User*, Channel*, const std::string&) { DetachEvent(I_OnCheckKey); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnCheckLimit(User*, Channel*) { DetachEvent(I_OnCheckLimit); return MOD_RES_PASSTHRU; }
@@ -151,13 +145,16 @@ void		Module::OnBuildNeighborList(User*, IncludeChanList&, std::map<User*,bool>&
 void		Module::OnGarbageCollect() { DetachEvent(I_OnGarbageCollect); }
 ModResult	Module::OnSetConnectClass(LocalUser* user, ConnectClass* myclass) { DetachEvent(I_OnSetConnectClass); return MOD_RES_PASSTHRU; }
 void 		Module::OnText(User*, void*, int, const std::string&, char, CUList&) { DetachEvent(I_OnText); }
-void		Module::OnRunTestSuite() { DetachEvent(I_OnRunTestSuite); }
-void		Module::OnNamesListItem(User*, Membership*, std::string&, std::string&) { DetachEvent(I_OnNamesListItem); }
+ModResult	Module::OnNamesListItem(User*, Membership*, std::string&, std::string&) { DetachEvent(I_OnNamesListItem); return MOD_RES_PASSTHRU; }
 ModResult	Module::OnNumeric(User*, unsigned int, const std::string&) { DetachEvent(I_OnNumeric); return MOD_RES_PASSTHRU; }
 ModResult   Module::OnAcceptConnection(int, ListenSocket*, irc::sockets::sockaddrs*, irc::sockets::sockaddrs*) { DetachEvent(I_OnAcceptConnection); return MOD_RES_PASSTHRU; }
-void		Module::OnSendWhoLine(User*, const std::vector<std::string>&, User*, std::string&) { DetachEvent(I_OnSendWhoLine); }
+void		Module::OnSendWhoLine(User*, const std::vector<std::string>&, User*, Membership*, std::string&) { DetachEvent(I_OnSendWhoLine); }
 void		Module::OnSetUserIP(LocalUser*) { DetachEvent(I_OnSetUserIP); }
 
+#ifdef INSPIRCD_ENABLE_TESTSUITE
+void		Module::OnRunTestSuite() { }
+#endif
+
 ServiceProvider::ServiceProvider(Module* Creator, const std::string& Name, ServiceType Type)
 	: creator(Creator), name(Name), service(Type)
 {
@@ -387,17 +384,20 @@ void ModuleManager::DoSafeUnload(Module* mod)
 	std::vector<reference<ExtensionItem> > items;
 	ServerInstance->Extensions.BeginUnregister(modfind->second, items);
 	/* Give the module a chance to tidy out all its metadata */
-	for (chan_hash::iterator c = ServerInstance->chanlist->begin(); c != ServerInstance->chanlist->end(); )
+	const chan_hash& chans = ServerInstance->GetChans();
+	for (chan_hash::const_iterator c = chans.begin(); c != chans.end(); )
 	{
 		Channel* chan = c->second;
 		++c;
 		mod->OnCleanup(TYPE_CHANNEL, chan);
 		chan->doUnhookExtensions(items);
-		const UserMembList* users = chan->GetUsers();
-		for(UserMembCIter mi = users->begin(); mi != users->end(); mi++)
+		const Channel::MemberMap& users = chan->GetUsers();
+		for (Channel::MemberMap::const_iterator mi = users.begin(); mi != users.end(); ++mi)
 			mi->second->doUnhookExtensions(items);
 	}
-	for (user_hash::iterator u = ServerInstance->Users->clientlist->begin(); u != ServerInstance->Users->clientlist->end(); )
+
+	const user_hash& users = ServerInstance->Users->GetUsers();
+	for (user_hash::const_iterator u = users.begin(); u != users.end(); )
 	{
 		User* user = u->second;
 		// The module may quit the user (e.g. SSL mod unloading) and that will remove it from the container
@@ -405,16 +405,25 @@ void ModuleManager::DoSafeUnload(Module* mod)
 		mod->OnCleanup(TYPE_USER, user);
 		user->doUnhookExtensions(items);
 	}
-	for(char m='A'; m <= 'z'; m++)
+
+	const ModeParser::ModeHandlerMap& usermodes = ServerInstance->Modes->GetModes(MODETYPE_USER);
+	for (ModeParser::ModeHandlerMap::const_iterator i = usermodes.begin(); i != usermodes.end(); )
 	{
-		ModeHandler* mh;
-		mh = ServerInstance->Modes->FindMode(m, MODETYPE_USER);
-		if (mh && mh->creator == mod)
+		ModeHandler* mh = i->second;
+		++i;
+		if (mh->creator == mod)
 			this->DelService(*mh);
-		mh = ServerInstance->Modes->FindMode(m, MODETYPE_CHANNEL);
-		if (mh && mh->creator == mod)
+	}
+
+	const ModeParser::ModeHandlerMap& chanmodes = ServerInstance->Modes->GetModes(MODETYPE_CHANNEL);
+	for (ModeParser::ModeHandlerMap::const_iterator i = chanmodes.begin(); i != chanmodes.end(); )
+	{
+		ModeHandler* mh = i->second;
+		++i;
+		if (mh->creator == mod)
 			this->DelService(*mh);
 	}
+
 	for(std::multimap<std::string, ServiceProvider*>::iterator i = DataProviders.begin(); i != DataProviders.end(); )
 	{
 		std::multimap<std::string, ServiceProvider*>::iterator curr = i++;
@@ -506,7 +515,7 @@ void ModuleManager::Reload(Module* mod, HandlerBase1<void, bool>* callback)
 {
 	if (CanUnload(mod))
 		ServerInstance->AtomicActions.AddAction(new ReloadAction(mod, callback));
-	else
+	else if (callback)
 		callback->Call(false);
 }
 
@@ -578,14 +587,13 @@ void ModuleManager::AddService(ServiceProvider& item)
 	switch (item.service)
 	{
 		case SERVICE_COMMAND:
-			if (!ServerInstance->Parser->AddCommand(static_cast<Command*>(&item)))
+			if (!ServerInstance->Parser.AddCommand(static_cast<Command*>(&item)))
 				throw ModuleException("Command "+std::string(item.name)+" already exists.");
 			return;
 		case SERVICE_MODE:
 		{
 			ModeHandler* mh = static_cast<ModeHandler*>(&item);
-			if (!ServerInstance->Modes->AddMode(mh))
-				throw ModuleException("Mode "+std::string(item.name)+" already exists.");
+			ServerInstance->Modes->AddMode(mh);
 			DataProviders.insert(std::make_pair((mh->GetModeType() == MODETYPE_CHANNEL ? "mode/" : "umode/") + item.name, &item));
 			dynamic_reference_base::reset_all();
 			return;
@@ -597,7 +605,7 @@ void ModuleManager::AddService(ServiceProvider& item)
 		case SERVICE_DATA:
 		case SERVICE_IOHOOK:
 		{
-			if ((item.name.substr(0, 5) == "mode/") || (item.name.substr(0, 6) == "umode/"))
+			if ((!item.name.compare(0, 5, "mode/", 5)) || (!item.name.compare(0, 6, "umode/", 6)))
 				throw ModuleException("The \"mode/\" and the \"umode\" service name prefixes are reserved.");
 
 			DataProviders.insert(std::make_pair(item.name, &item));
@@ -662,29 +670,21 @@ dynamic_reference_base::dynamic_reference_base(Module* Creator, const std::strin
 	: name(Name), value(NULL), creator(Creator)
 {
 	if (!dynrefs)
-		dynrefs = new std::vector<dynamic_reference_base*>;
-	dynrefs->push_back(this);
-	if (dynref_init_complete)
+		dynrefs = new insp::intrusive_list<dynamic_reference_base>;
+	dynrefs->push_front(this);
+
+	// Resolve unless there is no ModuleManager (part of class InspIRCd)
+	if (ServerInstance)
 		resolve();
 }
 
 dynamic_reference_base::~dynamic_reference_base()
 {
-	for(unsigned int i = 0; i < dynrefs->size(); i++)
+	dynrefs->erase(this);
+	if (dynrefs->empty())
 	{
-		if (dynrefs->at(i) == this)
-		{
-			unsigned int last = dynrefs->size() - 1;
-			if (i != last)
-				dynrefs->at(i) = dynrefs->at(last);
-			dynrefs->erase(dynrefs->begin() + last);
-			if (dynrefs->empty())
-			{
-				delete dynrefs;
-				dynrefs = NULL;
-			}
-			return;
-		}
+		delete dynrefs;
+		dynrefs = NULL;
 	}
 }