X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Fmain.cpp;h=1bc3dfe3925b9f7fed8c62b400ea438f0f337316;hb=164e9d9171850877161ae057764ff8b579bedd36;hp=c402b145a7afd76955f76bc5da68878d722502c7;hpb=5d67a5fff127bf95bca69b436ef7f645f2fe3281;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index c402b145a..1bc3dfe39 100644
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -14,8 +14,6 @@
 /* $ModDesc: Provides a spanning tree server link protocol */
 
 #include "inspircd.h"
-#include "commands/cmd_whois.h"
-#include "commands/cmd_stats.h"
 #include "socket.h"
 #include "xline.h"
 #include "../transport.h"
@@ -38,21 +36,21 @@ ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
 {
 	ServerInstance->Modules->UseInterface("BufferedSocketHook");
 	Utils = new SpanningTreeUtilities(ServerInstance, this);
-	command_rconnect = new CommandRConnect(ServerInstance, this, Utils);
+	command_rconnect = new CommandRConnect(this, Utils);
 	ServerInstance->AddCommand(command_rconnect);
-	command_rsquit = new CommandRSQuit(ServerInstance, this, Utils);
+	command_rsquit = new CommandRSQuit(this, Utils);
 	ServerInstance->AddCommand(command_rsquit);
 	RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils);
 	ServerInstance->Timers->AddTimer(RefreshTimer);
 
 	Implementation eventlist[] =
 	{
-		I_OnPreCommand, I_OnGetServerDescription, I_OnUserInvite, I_OnPostLocalTopicChange,
+		I_OnPreCommand, I_OnGetServerDescription, I_OnUserInvite, I_OnPostTopicChange,
 		I_OnWallops, I_OnUserNotice, I_OnUserMessage, I_OnBackgroundTimer, I_OnUserJoin,
-		I_OnChangeLocalUserHost, I_OnChangeName, I_OnUserPart, I_OnUnloadModule, I_OnUserQuit,
-		I_OnUserPostNick, I_OnUserKick, I_OnRemoteKill, I_OnRehash, I_OnPreRehash, I_OnOper,
-		I_OnAddLine, I_OnDelLine, I_OnMode, I_OnLoadModule, I_OnStats, I_OnEvent, I_OnSetAway,
-		I_OnPostCommand, I_OnUserConnect
+		I_OnChangeLocalUserHost, I_OnChangeName, I_OnChangeIdent, I_OnUserPart, I_OnUnloadModule,
+		I_OnUserQuit, I_OnUserPostNick, I_OnUserKick, I_OnRemoteKill, I_OnRehash, I_OnPreRehash,
+		I_OnOper, I_OnAddLine, I_OnDelLine, I_OnMode, I_OnLoadModule, I_OnStats, I_OnEvent,
+		I_OnSetAway, I_OnPostCommand, I_OnUserConnect
 	};
 	ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
 
@@ -246,13 +244,13 @@ void ModuleSpanningTree::DoPingChecks(time_t curtime)
 	}
 }
 
-void ModuleSpanningTree::ConnectServer(Link* x)
+void ModuleSpanningTree::ConnectServer(Link* x, Autoconnect* y)
 {
 	bool ipvalid = true;
 
 	if (InspIRCd::Match(ServerInstance->Config->ServerName, assign(x->Name)))
 	{
-		this->ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Not connecting to myself.");
+		ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Not connecting to myself.");
 		return;
 	}
 
@@ -277,17 +275,17 @@ void ModuleSpanningTree::ConnectServer(Link* x)
 		/* Gave a hook, but it wasnt one we know */
 		if ((!x->Hook.empty()) && (Utils->hooks.find(x->Hook.c_str()) == Utils->hooks.end()))
 			return;
-		TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port, x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]);
+		TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port, x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, y, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]);
 		if (newsocket->GetFd() > -1)
 		{
 			/* Handled automatically on success */
 		}
 		else
 		{
-			this->ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+			ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
 			if (ServerInstance->SocketCull.find(newsocket) == ServerInstance->SocketCull.end())
 				ServerInstance->SocketCull[newsocket] = newsocket;
-			Utils->DoFailOver(x);
+			Utils->DoFailOver(y);
 		}
 	}
 	else
@@ -295,25 +293,26 @@ void ModuleSpanningTree::ConnectServer(Link* x)
 		try
 		{
 			bool cached;
-			ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type);
+			ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type, y);
 			ServerInstance->AddResolver(snr, cached);
 		}
 		catch (ModuleException& e)
 		{
-			this->ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
-			Utils->DoFailOver(x);
+			ServerInstance->SNO->WriteToSnoMask('l', "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
+			Utils->DoFailOver(y);
 		}
 	}
 }
 
 void ModuleSpanningTree::AutoConnectServers(time_t curtime)
 {
-	for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
+	for (std::vector<Autoconnect>::iterator x = Utils->AutoconnectBlocks.begin(); x < Utils->AutoconnectBlocks.end(); ++x)
 	{
-		if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
+		if (curtime >= x->NextConnectTime)
 		{
-			x->NextConnectTime = curtime + x->AutoConnect;
-			TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
+			x->NextConnectTime = curtime + x->Period;
+			TreeServer* CheckDupe = Utils->FindServer(x->Server.c_str());
+			Link* y = Utils->FindLink(x->Server);
 			if (x->FailOver.length())
 			{
 				TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str());
@@ -329,8 +328,8 @@ void ModuleSpanningTree::AutoConnectServers(time_t curtime)
 			if (!CheckDupe)
 			{
 				// an autoconnected server is not connected. Check if its time to connect it
-				ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
-				this->ConnectServer(&(*x));
+				ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",y->Name.c_str(),x->Period);
+				this->ConnectServer(&(*y), &(*x));
 			}
 		}
 	}
@@ -338,7 +337,7 @@ void ModuleSpanningTree::AutoConnectServers(time_t curtime)
 
 void ModuleSpanningTree::DoConnectTimeout(time_t curtime)
 {
-	std::vector<Link*> failovers;
+	std::vector<Autoconnect*> failovers;
 	for (std::map<TreeSocket*, std::pair<std::string, int> >::iterator i = Utils->timeoutlist.begin(); i != Utils->timeoutlist.end(); i++)
 	{
 		TreeSocket* s = i->first;
@@ -346,21 +345,19 @@ void ModuleSpanningTree::DoConnectTimeout(time_t curtime)
 		if (curtime > s->age + p.second)
 		{
 			ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002 (timeout of %d seconds)",p.first.c_str(),p.second);
+			failovers.push_back(s->myautoconnect);
 			ServerInstance->SE->DelFd(s);
 			s->Close();
-			Link* MyLink = Utils->FindLink(p.first);
-			if (MyLink)
-				failovers.push_back(MyLink);
 		}
 	}
 	/* Trigger failover for each timed out socket */
-	for (std::vector<Link*>::const_iterator n = failovers.begin(); n != failovers.end(); ++n)
+	for (std::vector<Autoconnect*>::const_iterator n = failovers.begin(); n != failovers.end(); ++n)
 	{
 		Utils->DoFailOver(*n);
 	}
 }
 
-int ModuleSpanningTree::HandleVersion(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleVersion(const std::vector<std::string>& parameters, User* user)
 {
 	// we've already checked if pcnt > 0, so this is safe
 	TreeServer* found = Utils->FindServerMask(parameters[0]);
@@ -377,7 +374,7 @@ int ModuleSpanningTree::HandleVersion(const std::vector<std::string>& parameters
 	{
 		user->WriteNumeric(402, "%s %s :No such server",user->nick.c_str(),parameters[0].c_str());
 	}
-	return 1;
+	return MOD_RES_DENY;
 }
 
 /* This method will attempt to get a message to a remote user.
@@ -397,7 +394,7 @@ void ModuleSpanningTree::RemoteMessage(User* user, const char* format, ...)
 		ServerInstance->PI->SendUserNotice(user, text);
 }
 
-int ModuleSpanningTree::HandleConnect(const std::vector<std::string>& parameters, User* user)
+ModResult ModuleSpanningTree::HandleConnect(const std::vector<std::string>& parameters, User* user)
 {
 	for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 	{
@@ -406,25 +403,25 @@ int ModuleSpanningTree::HandleConnect(const std::vector<std::string>& parameters
 			if (InspIRCd::Match(ServerInstance->Config->ServerName, assign(x->Name)))
 			{
 				RemoteMessage(user, "*** CONNECT: Server \002%s\002 is ME, not connecting.",x->Name.c_str());
-				return 1;
+				return MOD_RES_DENY;
 			}
 
 			TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
 			if (!CheckDupe)
 			{
 				RemoteMessage(user, "*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
-				ConnectServer(&(*x));
-				return 1;
+				ConnectServer(&(*x), NULL);
+				return MOD_RES_DENY;
 			}
 			else
 			{
 				RemoteMessage(user, "*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str());
-				return 1;
+				return MOD_RES_DENY;
 			}
 		}
 	}
 	RemoteMessage(user, "*** CONNECT: No server matching \002%s\002 could be found in the config file.",parameters[0].c_str());
-	return 1;
+	return MOD_RES_DENY;
 }
 
 void ModuleSpanningTree::OnGetServerDescription(const std::string &servername,std::string &description)
@@ -448,8 +445,12 @@ void ModuleSpanningTree::OnUserInvite(User* source,User* dest,Channel* channel,
 	}
 }
 
-void ModuleSpanningTree::OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic)
+void ModuleSpanningTree::OnPostTopicChange(User* user, Channel* chan, const std::string &topic)
 {
+	// Drop remote events on the floor.
+	if (!IS_LOCAL(user))
+		return;
+
 	parameterlist params;
 	params.push_back(chan->name);
 	params.push_back(":"+topic);
@@ -598,32 +599,32 @@ void ModuleSpanningTree::OnUserConnect(User* user)
 	Utils->TreeRoot->SetUserCount(1); // increment by 1
 }
 
-void ModuleSpanningTree::OnUserJoin(User* user, Channel* channel, bool sync, bool &silent, bool created)
+void ModuleSpanningTree::OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts)
 {
 	// Only do this for local users
-	if (IS_LOCAL(user))
+	if (IS_LOCAL(memb->user))
 	{
 		parameterlist params;
 		// set up their permissions and the channel TS with FJOIN.
 		// All users are FJOINed now, because a module may specify
 		// new joining permissions for the user.
-		params.push_back(channel->name);
-		params.push_back(ConvToStr(channel->age));
-		params.push_back(std::string("+") + channel->ChanModes(true));
-		params.push_back(ServerInstance->Modes->ModeString(user, channel, false)+","+std::string(user->uuid));
+		params.push_back(memb->chan->name);
+		params.push_back(ConvToStr(memb->chan->age));
+		params.push_back(std::string("+") + memb->chan->ChanModes(true));
+		params.push_back(memb->modes+","+std::string(memb->user->uuid));
 		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
 	}
 }
 
-int ModuleSpanningTree::OnChangeLocalUserHost(User* user, const std::string &newhost)
+ModResult ModuleSpanningTree::OnChangeLocalUserHost(User* user, const std::string &newhost)
 {
 	if (user->registered != REG_ALL)
-		return 0;
+		return MOD_RES_PASSTHRU;
 
 	parameterlist params;
 	params.push_back(newhost);
 	Utils->DoOneToMany(user->uuid,"FHOST",params);
-	return 0;
+	return MOD_RES_PASSTHRU;
 }
 
 void ModuleSpanningTree::OnChangeName(User* user, const std::string &gecos)
@@ -637,15 +638,26 @@ void ModuleSpanningTree::OnChangeName(User* user, const std::string &gecos)
 	Utils->DoOneToMany(user->uuid,"FNAME",params);
 }
 
-void ModuleSpanningTree::OnUserPart(User* user, Channel* channel,  std::string &partmessage, bool &silent)
+void ModuleSpanningTree::OnChangeIdent(User* user, const std::string &ident)
 {
-	if (IS_LOCAL(user))
+	// only occurs for local clients
+	if (user->registered != REG_ALL)
+		return;
+
+	parameterlist params;
+	params.push_back(ident);
+	Utils->DoOneToMany(user->uuid,"FIDENT",params);
+}
+
+void ModuleSpanningTree::OnUserPart(Membership* memb, std::string &partmessage, CUList& excepts)
+{
+	if (IS_LOCAL(memb->user))
 	{
 		parameterlist params;
-		params.push_back(channel->name);
+		params.push_back(memb->chan->name);
 		if (!partmessage.empty())
 			params.push_back(":"+partmessage);
-		Utils->DoOneToMany(user->uuid,"PART",params);
+		Utils->DoOneToMany(memb->user->uuid,"PART",params);
 	}
 }
 
@@ -688,13 +700,20 @@ void ModuleSpanningTree::OnUserPostNick(User* user, const std::string &oldnick)
 		params.push_back(ConvToStr(user->age));
 		Utils->DoOneToMany(user->uuid,"NICK",params);
 	}
+	else if (!loopCall && user->nick == user->uuid)
+	{
+		parameterlist params;
+		params.push_back(user->uuid);
+		params.push_back(ConvToStr(user->age));
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"SAVE",params);
+	}
 }
 
-void ModuleSpanningTree::OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent)
+void ModuleSpanningTree::OnUserKick(User* source, Membership* memb, const std::string &reason, CUList& excepts)
 {
 	parameterlist params;
-	params.push_back(chan->name);
-	params.push_back(user->uuid);
+	params.push_back(memb->chan->name);
+	params.push_back(memb->user->uuid);
 	params.push_back(":"+reason);
 	if (IS_LOCAL(source))
 	{
@@ -711,13 +730,13 @@ void ModuleSpanningTree::OnRemoteKill(User* source, User* dest, const std::strin
 	if (!IS_LOCAL(source))
 		return; // Only start routing if we're origin.
 
+	User::OperQuit.set(dest, operreason);
 	parameterlist params;
-	params.push_back(":"+reason);
+	params.push_back(":"+operreason);
 	Utils->DoOneToMany(dest->uuid,"OPERQUIT",params);
 	params.clear();
 	params.push_back(dest->uuid);
 	params.push_back(":"+reason);
-	dest->SetOperQuit(operreason);
 	Utils->DoOneToMany(source->uuid,"KILL",params);
 }
 
@@ -788,7 +807,7 @@ void ModuleSpanningTree::OnAddLine(User* user, XLine *x)
 
 	char data[MAXBUF];
 	snprintf(data,MAXBUF,"%s %s %s %lu %lu :%s", x->type.c_str(), x->Displayable(),
-	ServerInstance->Config->ServerName, (unsigned long)x->set_time, (unsigned long)x->duration, x->reason);
+	ServerInstance->Config->ServerName, (unsigned long)x->set_time, (unsigned long)x->duration, x->reason.c_str());
 	parameterlist params;
 	params.push_back(data);
 
@@ -856,25 +875,25 @@ void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const p
 	}
 }
 
-int ModuleSpanningTree::OnSetAway(User* user, const std::string &awaymsg)
+ModResult ModuleSpanningTree::OnSetAway(User* user, const std::string &awaymsg)
 {
 	if (IS_LOCAL(user))
 	{
 		if (awaymsg.empty())
 		{
 			parameterlist params;
-			params.clear();
 			Utils->DoOneToMany(user->uuid,"AWAY",params);
 		}
 		else
 		{
 			parameterlist params;
+			params.push_back(ConvToStr(user->awaytime));
 			params.push_back(":" + awaymsg);
 			Utils->DoOneToMany(user->uuid,"AWAY",params);
 		}
 	}
 
-	return 0;
+	return MOD_RES_PASSTHRU;
 }
 
 void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const parameterlist &modeline, const std::vector<TranslateType> &translate)
@@ -899,26 +918,17 @@ void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type
 	}
 }
 
-void ModuleSpanningTree::ProtoSendMetaData(void* opaque, TargetTypeFlags target_type, void* target, const std::string &extname, const std::string &extdata)
+void ModuleSpanningTree::ProtoSendMetaData(void* opaque, Extensible* target, const std::string &extname, const std::string &extdata)
 {
-	TreeSocket* s = (TreeSocket*)opaque;
-	if (target)
-	{
-		if (target_type == TYPE_USER)
-		{
-			User* u = (User*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
-		}
-		else if (target_type == TYPE_CHANNEL)
-		{
-			Channel* c = (Channel*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata);
-		}
-	}
-	if (target_type == TYPE_OTHER)
-	{
+	TreeSocket* s = static_cast<TreeSocket*>(opaque);
+	User* u = dynamic_cast<User*>(target);
+	Channel* c = dynamic_cast<Channel*>(target);
+	if (u)
+		s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
+	else if (c)
+		s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata);
+	else if (!target)
 		s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
-	}
 }
 
 void ModuleSpanningTree::OnEvent(Event* event)