X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Fmain.cpp;h=9d7b7db790afbcca368aae49548ece4d289dd6c9;hb=316e19f10c1d30215a2617f44ca61f8d6d2559a8;hp=1fd33b946be551e18a4234047a7d2785b08f2362;hpb=5bbc794c7db6363e8f43b69a6f19307dfc411a04;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index 1fd33b946..9d7b7db79 100644
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -13,14 +13,10 @@
 
 /* $ModDesc: Provides a spanning tree server link protocol */
 
-#include "configreader.h"
-#include "users.h"
-#include "channels.h"
-#include "modules.h"
+#include "inspircd.h"
 #include "commands/cmd_whois.h"
 #include "commands/cmd_stats.h"
 #include "socket.h"
-#include "inspircd.h"
 #include "wildcard.h"
 #include "xline.h"
 #include "transport.h"
@@ -33,16 +29,19 @@
 #include "m_spanningtree/link.h"
 #include "m_spanningtree/treesocket.h"
 #include "m_spanningtree/rconnect.h"
+#include "m_spanningtree/rsquit.h"
 
-/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h */
+/* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h m_spanningtree/rsquit.h */
 
 ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
-	: Module::Module(Me), max_local(0), max_global(0)
+	: Module(Me), max_local(0), max_global(0)
 {
 	ServerInstance->UseInterface("InspSocketHook");
 	Utils = new SpanningTreeUtilities(Me, this);
 	command_rconnect = new cmd_rconnect(ServerInstance, this, Utils);
 	ServerInstance->AddCommand(command_rconnect);
+	command_rsquit = new cmd_rsquit(ServerInstance, this, Utils);
+	ServerInstance->AddCommand(command_rsquit);
 	if (Utils->EnableTimeSync)
 	{
 		SyncTimer = new TimeSyncTimer(ServerInstance, this);
@@ -50,6 +49,9 @@ ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
 	}
 	else
 		SyncTimer = NULL;
+
+	RefreshTimer = new CacheRefreshTimer(ServerInstance, Utils);
+	ServerInstance->Timers->AddTimer(RefreshTimer);
 }
 
 void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops)
@@ -61,7 +63,7 @@ void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops)
 	}
 	for (unsigned int q = 0; q < Current->ChildCount(); q++)
 	{
-		if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
+		if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))))
 		{
 			if (*user->oper)
 			{
@@ -74,9 +76,16 @@ void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops)
 		}
 	}
 	/* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
-	if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper))
+	if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!IS_OPER(user)))
+		return;
+	/* Or if the server is hidden and they're not an oper */
+	else if ((Current->Hidden) && (!IS_OPER(user)))
 		return;
-	user->WriteServ("364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(Utils->FlatLinks && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(Utils->FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
+
+	user->WriteServ("364 %s %s %s :%d %s",	user->nick,Current->GetName().c_str(),
+			(Utils->FlatLinks && (!IS_OPER(user))) ? ServerInstance->Config->ServerName : Parent.c_str(),
+			(Utils->FlatLinks && (!IS_OPER(user))) ? 0 : hops,
+			Current->GetDesc().c_str());
 }
 
 int ModuleSpanningTree::CountLocalServs()
@@ -124,21 +133,48 @@ void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, userrec
 			}
 		}
 	}
-	user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-ServerInstance->InvisibleUserCount(),ServerInstance->InvisibleUserCount(),ulined_count ? this->CountServs() - ulined_count : this->CountServs());
+	user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,
+			n_users-ServerInstance->InvisibleUserCount(),
+			ServerInstance->InvisibleUserCount(),
+			ulined_count ? this->CountServs() - ulined_count : this->CountServs());
+
 	if (ServerInstance->OperCount())
 		user->WriteServ("252 %s %d :operator(s) online",user->nick,ServerInstance->OperCount());
+
 	if (ServerInstance->UnregisteredUserCount())
 		user->WriteServ("253 %s %d :unknown connections",user->nick,ServerInstance->UnregisteredUserCount());
+	
 	if (ServerInstance->ChannelCount())
 		user->WriteServ("254 %s %d :channels formed",user->nick,ServerInstance->ChannelCount());
-	user->WriteServ("254 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs());
+	
+	user->WriteServ("255 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs());
 	user->WriteServ("265 %s :Current Local Users: %d  Max: %d",user->nick,ServerInstance->LocalUserCount(),max_local);
 	user->WriteServ("266 %s :Current Global Users: %d  Max: %d",user->nick,n_users,max_global);
 	return;
 }
 
+std::string ModuleSpanningTree::TimeToStr(time_t secs)
+{
+	time_t mins_up = secs / 60;
+	time_t hours_up = mins_up / 60;
+	time_t days_up = hours_up / 24;
+	secs = secs % 60;
+	mins_up = mins_up % 60;
+	hours_up = hours_up % 24;
+	return ((days_up ? (ConvToStr(days_up) + "d") : std::string(""))
+			+ (hours_up ? (ConvToStr(hours_up) + "h") : std::string(""))
+			+ (mins_up ? (ConvToStr(mins_up) + "m") : std::string(""))
+			+ ConvToStr(secs) + "s");
+}
+
+const std::string ModuleSpanningTree::MapOperInfo(TreeServer* Current)
+{
+	time_t secs_up = ServerInstance->Time() - Current->age;
+	return (" [Up: " + TimeToStr(secs_up) + " Lag: "+ConvToStr(Current->rtt)+"ms]");
+}
+
 // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS.
-void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80], float &totusers, float &totservers)
+void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][128], float &totusers, float &totservers)
 {
 	if (line < 128)
 	{
@@ -158,7 +194,10 @@ void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth,
 			spacer[5] = '\0';
 		}
 		float percent;
-		char text[80];
+		char text[128];
+		/* Neat and tidy default values, as we're dealing with a matrix not a simple string */
+		memset(text, 0, 128);
+
 		if (ServerInstance->clientlist->size() == 0) {
 			// If there are no users, WHO THE HELL DID THE /MAP?!?!?!
 			percent = 0;
@@ -167,14 +206,15 @@ void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth,
 		{
 			percent = ((float)Current->GetUserCount() / (float)ServerInstance->clientlist->size()) * 100;
 		}
-		snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent);
+		const std::string operdata = IS_OPER(user) ? MapOperInfo(Current) : "";
+		snprintf(text, 126, "%s %s%5d [%5.2f%%]%s", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent, operdata.c_str());
 		totusers += Current->GetUserCount();
 		totservers++;
-		strlcpy(&matrix[line][depth],text,80);
+		strlcpy(&matrix[line][depth],text,126);
 		line++;
 		for (unsigned int q = 0; q < Current->ChildCount(); q++)
 		{
-			if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
+			if ((Current->GetChild(q)->Hidden) || ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str()))))
 			{
 				if (*user->oper)
 				{
@@ -193,6 +233,9 @@ int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* u
 {
 	if (pcnt > 0)
 	{
+		if (match(ServerInstance->Config->ServerName, parameters[0]))
+			return 0;
+
 		/* Remote MOTD, the server is within the 1st parameter */
 		std::deque<std::string> params;
 		params.push_back(parameters[0]);
@@ -200,12 +243,11 @@ int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* u
 		TreeServer* s = Utils->FindServerMask(parameters[0]);
 		if (s)
 		{
-			Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName());
+			params[0] = s->GetName();
+			Utils->DoOneToOne(user->uuid, "MOTD", params, s->GetName());
 		}
 		else
-		{
 			user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
-		}
 		return 1;
 	}
 	return 0;
@@ -215,6 +257,9 @@ int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec*
 {
 	if (pcnt > 0)
 	{
+		if (match(ServerInstance->Config->ServerName, parameters[0]))
+			return 0;
+
 		/* Remote ADMIN, the server is within the 1st parameter */
 		std::deque<std::string> params;
 		params.push_back(parameters[0]);
@@ -222,12 +267,33 @@ int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec*
 		TreeServer* s = Utils->FindServerMask(parameters[0]);
 		if (s)
 		{
-			Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName());
+			params[0] = s->GetName();
+			Utils->DoOneToOne(user->uuid, "ADMIN", params, s->GetName());
 		}
 		else
-		{
 			user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
+		return 1;
+	}
+	return 0;
+}
+
+int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, userrec* user)
+{
+	if (pcnt > 0)
+	{
+		if (match(ServerInstance->Config->ServerName, parameters[0]))
+			return 0;
+
+		std::deque<std::string> params;
+		params.push_back(parameters[0]);
+		TreeServer* s = Utils->FindServerMask(parameters[0]);
+		if (s)
+		{
+			params[0] = s->GetName();
+			Utils->DoOneToOne(user->uuid, "MODULES", params, s->GetName());
 		}
+		else
+			user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
 		return 1;
 	}
 	return 0;
@@ -237,20 +303,24 @@ int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec*
 {
 	if (pcnt > 1)
 	{
+		if (match(ServerInstance->Config->ServerName, parameters[1]))
+			return 0;
+
 		/* Remote STATS, the server is within the 2nd parameter */
 		std::deque<std::string> params;
 		params.push_back(parameters[0]);
 		params.push_back(parameters[1]);
 		/* Send it out remotely, generate no reply yet */
+
 		TreeServer* s = Utils->FindServerMask(parameters[1]);
 		if (s)
 		{
 			params[1] = s->GetName();
-			Utils->DoOneToOne(user->nick, "STATS", params, s->GetName());
+			Utils->DoOneToOne(user->uuid, "STATS", params, s->GetName());
 		}
 		else
 		{
-			user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
+			user->WriteServ( "402 %s %s :No such server", user->nick, parameters[1]);
 		}
 		return 1;
 	}
@@ -272,7 +342,7 @@ void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, userrec* u
 	// client does not provide for a proper terminal.
 	float totusers = 0;
 	float totservers = 0;
-	char matrix[128][80];
+	char matrix[128][128];
 	for (unsigned int t = 0; t < 128; t++)
 	{
 		matrix[t][0] = '\0';
@@ -338,15 +408,11 @@ int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec*
 			sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost());
 			ServerInstance->SE->DelFd(sock);
 			sock->Close();
-			delete sock;
 		}
 		else
 		{
-			/* route it */
-			std::deque<std::string> params;
-			params.push_back(parameters[0]);
-			params.push_back(std::string(":Server quit by ") + user->GetFullRealHost());
-			Utils->DoOneToOne(user->nick, "RSQUIT", params, parameters[0]);
+			if (IS_LOCAL(user))
+				user->WriteServ("NOTICE %s :*** WARNING: Using SQUIT to split remote servers is deprecated. Please use RSQUIT instead.",user->nick);
 		}
 	}
 	else
@@ -369,8 +435,8 @@ int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, userrec* u
 			
 			std::deque<std::string> params;
 			params.push_back(found->GetName());
-			params.push_back(user->nick);
-			Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName());
+			params.push_back(user->uuid);
+			Utils->DoOneToOne(ServerInstance->Config->GetSID(),"TIME",params,found->GetName());
 		}
 		else
 		{
@@ -389,7 +455,7 @@ int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, use
 		{
 			std::deque<std::string> params;
 			params.push_back(parameters[1]);
-			Utils->DoOneToOne(user->nick,"IDLE",params,remote->server);
+			Utils->DoOneToOne(user->uuid,"IDLE",params,remote->server);
 			return 1;
 		}
 		else if (!remote)
@@ -414,22 +480,39 @@ void ModuleSpanningTree::DoPingChecks(time_t curtime)
 			{
 				if (serv->AnsweredLastPing())
 				{
-					sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName());
-					serv->SetNextPingTime(curtime + 60);
+					sock->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" PING "+serv->GetName());
+					serv->SetNextPingTime(curtime + Utils->PingFreq);
+					serv->LastPing = curtime;
+					timeval t;
+					gettimeofday(&t, NULL);
+					long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000);
+					serv->LastPingMsec = ts;
+					serv->Warned = false;
 				}
 				else
 				{
-					// they didnt answer, boot them
-					ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 pinged out",serv->GetName().c_str());
+					/* they didnt answer, boot them */
+					sock->SendError("Ping timeout");
 					sock->Squit(serv,"Ping timeout");
 					ServerInstance->SE->DelFd(sock);
 					sock->Close();
-					delete sock;
 					return;
 				}
 			}
+			else if ((Utils->PingWarnTime) && (!serv->Warned) && (curtime >= serv->NextPingTime() - (Utils->PingFreq - Utils->PingWarnTime)) && (!serv->AnsweredLastPing()))
+			{
+				/* The server hasnt responded, send a warning to opers */
+				ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 has not responded to PING for %d seconds, high latency.", serv->GetName().c_str(), Utils->PingWarnTime);
+				serv->Warned = true;
+			}
 		}
 	}
+
+	/* Cancel remote burst mode on any servers which still have it enabled due to latency/lack of data.
+	 * This prevents lost REMOTECONNECT notices
+	 */
+	for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++)
+		Utils->SetRemoteBursting(i->second, false);
 }
 
 void ModuleSpanningTree::ConnectServer(Link* x)
@@ -445,16 +528,12 @@ void ModuleSpanningTree::ConnectServer(Link* x)
 			ipvalid = false;
 	}
 	else
+#endif
 	{
 		in_addr n;
 		if (inet_aton(x->IPAddr.c_str(),&n) < 1)
 			ipvalid = false;
 	}
-#else
-		in_addr n;
-		if (inet_aton(x->IPAddr.c_str(),&n) < 1)
-			ipvalid = false;
-#endif
 
 	/* Do we already have an IP? If so, no need to resolve it. */
 	if (ipvalid)
@@ -469,8 +548,9 @@ void ModuleSpanningTree::ConnectServer(Link* x)
 		}
 		else
 		{
-			ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
-			delete newsocket;
+			RemoteMessage(NULL, "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);
 		}
 	}
@@ -484,7 +564,7 @@ void ModuleSpanningTree::ConnectServer(Link* x)
 		}
 		catch (ModuleException& e)
 		{
-			ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
+			RemoteMessage(NULL, "CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
 			Utils->DoFailOver(x);
 		}
 	}
@@ -539,6 +619,45 @@ int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, userrec
 	}
 	return 1;
 }
+
+/* This method will attempt to get a link message out to as many people as is required.
+ * If a user is provided, and that user is local, then the user is sent the message using
+ * WriteServ (they are the local initiator of that message). If the user is remote, they are
+ * sent that message remotely via PUSH.
+ * If the user is NULL, then the notice is sent locally via WriteToSnoMask with snomask 'l',
+ * and remotely via SNONOTICE with mask 'l'.
+ */
+void ModuleSpanningTree::RemoteMessage(userrec* user, const char* format, ...)
+{
+	std::deque<std::string> params;
+	char text[MAXBUF];
+	va_list argsPtr;
+
+	va_start(argsPtr, format);
+	vsnprintf(text, MAXBUF, format, argsPtr);
+	va_end(argsPtr);
+
+	if (!user)
+	{
+		/* No user, target it generically at everyone */
+		ServerInstance->SNO->WriteToSnoMask('l', "%s", text);
+		params.push_back("l");
+		params.push_back(std::string(":") + text);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(), "SNONOTICE", params);
+	}
+	else
+	{
+		if (IS_LOCAL(user))
+			user->WriteServ("NOTICE %s :%s", user->nick, text);
+		else
+		{
+			params.push_back(user->uuid);
+			params.push_back(std::string("::") + ServerInstance->Config->ServerName + " NOTICE " + user->nick + " :*** From " +
+					ServerInstance->Config->ServerName+ ": " + text);
+			Utils->DoOneToMany(ServerInstance->Config->GetSID(), "PUSH", params);
+		}
+	}
+}
 	
 int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user)
 {
@@ -549,18 +668,18 @@ int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec
 			TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
 			if (!CheckDupe)
 			{
-				user->WriteServ("NOTICE %s :*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
+				RemoteMessage(user, "*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
 				ConnectServer(&(*x));
 				return 1;
 			}
 			else
 			{
-				user->WriteServ("NOTICE %s :*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",user->nick,x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str());
+				RemoteMessage(user, "*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",user->nick,x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str());
 				return 1;
 			}
 		}
 	}
-	user->WriteServ("NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]);
+	RemoteMessage(user, "NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]);
 	return 1;
 }
 
@@ -571,7 +690,7 @@ void ModuleSpanningTree::BroadcastTimeSync()
 		std::deque<std::string> params;
 		params.push_back(ConvToStr(ServerInstance->Time(false)));
 		params.push_back("FORCE");
-		Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(), "TIMESET", params);
 	}
 }
 
@@ -589,6 +708,25 @@ int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &resu
 		ServerInstance->SNO->WriteToSnoMask('t',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
 		return 1;
 	}
+
+	if (statschar == 'p')
+	{
+		/* show all server ports, after showing client ports. -- w00t */
+
+		for (unsigned int i = 0; i < Utils->Bindings.size(); i++)
+		{
+			std::string ip = Utils->Bindings[i]->IP;
+			if (ip.empty())
+				ip = "*";
+
+			std::string transport("plaintext");
+			if (Utils->Bindings[i]->GetHook())
+				transport = InspSocketNameRequest(this, Utils->Bindings[i]->GetHook()).Send();
+
+			results.push_back(ConvToStr(ServerInstance->Config->ServerName) + " 249 "+user->nick+" :" + ip + ":" + ConvToStr(Utils->Bindings[i]->port)+
+				" (server, " + transport + ")");
+		}
+	}
 	return 0;
 }
 
@@ -597,6 +735,7 @@ int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** pa
 	/* If the command doesnt appear to be valid, we dont want to mess with it. */
 	if (!validated)
 		return 0;
+
 	if (command == "CONNECT")
 	{
 		return this->HandleConnect(parameters,pcnt,user);
@@ -649,6 +788,10 @@ int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** pa
 		this->HandleVersion(parameters,pcnt,user);
 		return 1;
 	}
+	else if ((command == "MODULES") && (pcnt > 0))
+	{
+		return this->HandleModules(parameters,pcnt,user);
+	}
 	return 0;
 }
 
@@ -656,6 +799,8 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const char**
 {
 	if ((result == CMD_SUCCESS) && (ServerInstance->IsValidModuleCommand(command, pcnt, user)))
 	{
+		/* Safe, we know its non-null because IsValidModuleCommand returned true */
+		command_t* thiscmd = ServerInstance->Parser->GetHandler(command);
 		// this bit of code cleverly routes all module commands
 		// to all remote severs *automatically* so that modules
 		// can just handle commands locally, without having
@@ -663,18 +808,31 @@ void ModuleSpanningTree::OnPostCommand(const std::string &command, const char**
 		// commands and linking protocols.
 		std::deque<std::string> params;
 		params.clear();
+		int n_translate = thiscmd->translation.size();
+		TranslateType translate_to;
+
 		for (int j = 0; j < pcnt; j++)
 		{
-			if (strchr(parameters[j],' '))
+			std::string target;
+
+			/* Map all items to UUIDs where neccessary */
+			if (j < n_translate)
 			{
-				params.push_back(":" + std::string(parameters[j]));
+				/* We have a translation mapping for this index */
+				translate_to = thiscmd->translation[j] != TR_END ? thiscmd->translation[j] : TR_TEXT;
 			}
 			else
-			{
-				params.push_back(std::string(parameters[j]));
-			}
+				translate_to = TR_TEXT;
+
+			ServerInstance->Log(DEBUG,"TRANSLATION: %s - type is %d", parameters[j], translate_to);
+			ServerInstance->Parser->TranslateUIDs(translate_to, parameters[j], target);
+
+			if (strchr(parameters[j],' '))
+				params.push_back(":" + target);
+			else
+				params.push_back(target);
 		}
-		Utils->DoOneToMany(user->nick,command,params);
+		Utils->DoOneToMany(user->uuid, command, params);
 	}
 }
 
@@ -692,9 +850,9 @@ void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* cha
 	if (IS_LOCAL(source))
 	{
 		std::deque<std::string> params;
-		params.push_back(dest->nick);
+		params.push_back(dest->uuid);
 		params.push_back(channel->name);
-		Utils->DoOneToMany(source->nick,"INVITE",params);
+		Utils->DoOneToMany(source->uuid,"INVITE",params);
 	}
 }
 
@@ -703,7 +861,7 @@ void ModuleSpanningTree::OnPostLocalTopicChange(userrec* user, chanrec* chan, co
 	std::deque<std::string> params;
 	params.push_back(chan->name);
 	params.push_back(":"+topic);
-	Utils->DoOneToMany(user->nick,"TOPIC",params);
+	Utils->DoOneToMany(user->uuid,"TOPIC",params);
 }
 
 void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text)
@@ -712,7 +870,7 @@ void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text)
 	{
 		std::deque<std::string> params;
 		params.push_back(":"+text);
-		Utils->DoOneToMany(user->nick,"WALLOPS",params);
+		Utils->DoOneToMany(user->uuid,"WALLOPS",params);
 	}
 }
 
@@ -725,9 +883,9 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type
 		{
 			std::deque<std::string> params;
 			params.clear();
-			params.push_back(d->nick);
+			params.push_back(d->uuid);
 			params.push_back(":"+text);
-			Utils->DoOneToOne(user->nick,"NOTICE",params,d->server);
+			Utils->DoOneToOne(user->uuid,"NOTICE",params,d->server);
 		}
 	}
 	else if (target_type == TYPE_CHANNEL)
@@ -746,7 +904,7 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type
 				{
 					TreeSocket* Sock = i->second->GetSocket();
 					if (Sock)
-						Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text);
+						Sock->WriteLine(":"+std::string(user->uuid)+" NOTICE "+cname+" :"+text);
 				}
 			}
 		}
@@ -759,7 +917,7 @@ void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type
 			std::deque<std::string> par;
 			par.push_back(target);
 			par.push_back(":"+text);
-			Utils->DoOneToMany(user->nick,"NOTICE",par);
+			Utils->DoOneToMany(user->uuid,"NOTICE",par);
 		}
 	}
 }
@@ -775,9 +933,9 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ
 		{
 			std::deque<std::string> params;
 			params.clear();
-			params.push_back(d->nick);
+			params.push_back(d->uuid);
 			params.push_back(":"+text);
-			Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server);
+			Utils->DoOneToOne(user->uuid,"PRIVMSG",params,d->server);
 		}
 	}
 	else if (target_type == TYPE_CHANNEL)
@@ -796,7 +954,7 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ
 				{
 					TreeSocket* Sock = i->second->GetSocket();
 					if (Sock)
-						Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text);
+						Sock->WriteLine(":"+std::string(user->uuid)+" PRIVMSG "+cname+" :"+text);
 				}
 			}
 		}
@@ -809,7 +967,7 @@ void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_typ
 			std::deque<std::string> par;
 			par.push_back(target);
 			par.push_back(":"+text);
-			Utils->DoOneToMany(user->nick,"PRIVMSG",par);
+			Utils->DoOneToMany(user->uuid,"PRIVMSG",par);
 		}
 	}
 }
@@ -820,7 +978,7 @@ void ModuleSpanningTree::OnBackgroundTimer(time_t curtime)
 	DoPingChecks(curtime);
 }
 
-void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel)
+void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel, bool &silent)
 {
 	// Only do this for local users
 	if (IS_LOCAL(user))
@@ -833,20 +991,19 @@ void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel)
 			// new joining permissions for the user.
 			params.push_back(channel->name);
 			params.push_back(ConvToStr(channel->age));
-			params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->nick));
-			Utils->DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
+			params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->uuid));
+			Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FJOIN",params);
 			/* First user in, sync the modes for the channel */
 			params.pop_back();
-			/* This is safe, all inspircd servers default to +nt */
-			params.push_back("+nt");
-			Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params);
+			params.push_back(channel->ChanModes(true));
+			Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",params);
 		}
 		else
 		{
 			std::deque<std::string> params;
 			params.push_back(channel->name);
 			params.push_back(ConvToStr(channel->age));
-			Utils->DoOneToMany(user->nick,"JOIN",params);
+			Utils->DoOneToMany(user->uuid,"JOIN",params);
 		}
 	}
 }
@@ -858,7 +1015,7 @@ void ModuleSpanningTree::OnChangeHost(userrec* user, const std::string &newhost)
 		return;
 	std::deque<std::string> params;
 	params.push_back(newhost);
-	Utils->DoOneToMany(user->nick,"FHOST",params);
+	Utils->DoOneToMany(user->uuid,"FHOST",params);
 }
 
 void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos)
@@ -868,18 +1025,18 @@ void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos)
 		return;
 	std::deque<std::string> params;
 	params.push_back(gecos);
-	Utils->DoOneToMany(user->nick,"FNAME",params);
+	Utils->DoOneToMany(user->uuid,"FNAME",params);
 }
 
-void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage)
+void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent)
 {
 	if (IS_LOCAL(user))
 	{
 		std::deque<std::string> params;
 		params.push_back(channel->name);
-		if (partmessage != "")
+		if (!partmessage.empty())
 			params.push_back(":"+partmessage);
-		Utils->DoOneToMany(user->nick,"PART",params);
+		Utils->DoOneToMany(user->uuid,"PART",params);
 	}
 }
 
@@ -890,6 +1047,7 @@ void ModuleSpanningTree::OnUserConnect(userrec* user)
 	{
 		std::deque<std::string> params;
 		snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
+		params.push_back(user->uuid);
 		params.push_back(agestr);
 		params.push_back(user->nick);
 		params.push_back(user->host);
@@ -898,7 +1056,7 @@ void ModuleSpanningTree::OnUserConnect(userrec* user)
 		params.push_back("+"+std::string(user->FormatModes()));
 		params.push_back(user->GetIPString());
 		params.push_back(":"+std::string(user->fullname));
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(), "UID", params);
 		// User is Local, change needs to be reflected!
 		TreeServer* SourceServer = Utils->FindServer(user->server);
 		if (SourceServer)
@@ -917,11 +1075,11 @@ void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason, co
 		if (oper_message != reason)
 		{
 			params.push_back(":"+oper_message);
-			Utils->DoOneToMany(user->nick,"OPERQUIT",params);
+			Utils->DoOneToMany(user->uuid,"OPERQUIT",params);
 		}
 		params.clear();
 		params.push_back(":"+reason);
-		Utils->DoOneToMany(user->nick,"QUIT",params);
+		Utils->DoOneToMany(user->uuid,"QUIT",params);
 	}
 	// Regardless, We need to modify the user Counts..
 	TreeServer* SourceServer = Utils->FindServer(user->server);
@@ -937,45 +1095,56 @@ void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnic
 	{
 		std::deque<std::string> params;
 		params.push_back(user->nick);
-		Utils->DoOneToMany(oldnick,"NICK",params);
+
+		/** IMPORTANT: We don't update the TS if the oldnick is just a case change of the newnick!
+		 */
+		if (irc::string(user->nick) != assign(oldnick))
+			user->age = ServerInstance->Time(true);
+
+		params.push_back(ConvToStr(user->age));
+		Utils->DoOneToMany(user->uuid,"NICK",params);
 	}
 }
 
-void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason)
+void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent)
 {
 	if ((source) && (IS_LOCAL(source)))
 	{
 		std::deque<std::string> params;
 		params.push_back(chan->name);
-		params.push_back(user->nick);
+		params.push_back(user->uuid);
 		params.push_back(":"+reason);
-		Utils->DoOneToMany(source->nick,"KICK",params);
+		Utils->DoOneToMany(source->uuid,"KICK",params);
 	}
 	else if (!source)
 	{
 		std::deque<std::string> params;
 		params.push_back(chan->name);
-		params.push_back(user->nick);
+		params.push_back(user->uuid);
 		params.push_back(":"+reason);
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"KICK",params);
 	}
 }
 
-void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason)
+void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason, const std::string &operreason)
 {
 	std::deque<std::string> params;
-	params.push_back(dest->nick);
 	params.push_back(":"+reason);
-	Utils->DoOneToMany(source->nick,"KILL",params);
+	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);
 }
 
 void ModuleSpanningTree::OnRehash(userrec* user, const std::string &parameter)
 {
-	if (parameter != "")
+	if (!parameter.empty())
 	{
 		std::deque<std::string> params;
 		params.push_back(parameter);
-		Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params);
+		Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->GetSID(), "REHASH", params);
 		// check for self
 		if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter))
 		{
@@ -996,7 +1165,7 @@ void ModuleSpanningTree::OnOper(userrec* user, const std::string &opertype)
 	{
 		std::deque<std::string> params;
 		params.push_back(opertype);
-		Utils->DoOneToMany(user->nick,"OPERTYPE",params);
+		Utils->DoOneToMany(user->uuid,"OPERTYPE",params);
 	}
 }
 
@@ -1010,7 +1179,7 @@ void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool a
 				(unsigned long)duration, reason.c_str());
 		std::deque<std::string> params;
 		params.push_back(data);
-		Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(), "ADDLINE", params);
 	}
 	else
 	{
@@ -1027,13 +1196,13 @@ void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool a
 				params.push_back(host);
 				params.push_back(sduration);
 				params.push_back(":"+reason);
-				Utils->DoOneToMany(source->nick,stype,params);
+				Utils->DoOneToMany(source->uuid,stype,params);
 			}
 			else
 			{
 				std::deque<std::string> params;
 				params.push_back(host);
-				Utils->DoOneToMany(source->nick,stype,params);
+				Utils->DoOneToMany(source->uuid,stype,params);
 			}
 		}
 	}
@@ -1083,22 +1252,29 @@ void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, cons
 {
 	if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
 	{
+		std::deque<std::string> params;
+		std::string command;
+		std::string output_text;
+
+		ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, text, output_text);
+
 		if (target_type == TYPE_USER)
 		{
 			userrec* u = (userrec*)dest;
-			std::deque<std::string> params;
-			params.push_back(u->nick);
-			params.push_back(text);
-			Utils->DoOneToMany(user->nick,"MODE",params);
+			params.push_back(u->uuid);
+			params.push_back(output_text);
+			command = "MODE";
 		}
 		else
 		{
 			chanrec* c = (chanrec*)dest;
-			std::deque<std::string> params;
 			params.push_back(c->name);
-			params.push_back(text);
-			Utils->DoOneToMany(user->nick,"MODE",params);
+			params.push_back(ConvToStr(c->age));
+			params.push_back(output_text);
+			command = "FMODE";
 		}
+
+		Utils->DoOneToMany(user->uuid, command, params);
 	}
 }
 
@@ -1108,7 +1284,7 @@ void ModuleSpanningTree::OnSetAway(userrec* user)
 	{
 		std::deque<std::string> params;
 		params.push_back(":"+std::string(user->awaymsg));
-		Utils->DoOneToMany(user->nick,"AWAY",params);
+		Utils->DoOneToMany(user->uuid,"AWAY",params);
 	}
 }
 
@@ -1118,24 +1294,28 @@ void ModuleSpanningTree::OnCancelAway(userrec* user)
 	{
 		std::deque<std::string> params;
 		params.clear();
-		Utils->DoOneToMany(user->nick,"AWAY",params);
+		Utils->DoOneToMany(user->uuid,"AWAY",params);
 	}
 }
 
 void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline)
 {
 	TreeSocket* s = (TreeSocket*)opaque;
+	std::string output_text;
+
+	ServerInstance->Parser->TranslateUIDs(TR_SPACENICKLIST, modeline, output_text);
+
 	if (target)
 	{
 		if (target_type == TYPE_USER)
 		{
 			userrec* u = (userrec*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline);
+			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+u->uuid+" "+ConvToStr(u->age)+" "+output_text);
 		}
 		else
 		{
 			chanrec* c = (chanrec*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline);
+			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+output_text);
 		}
 	}
 }
@@ -1148,17 +1328,17 @@ void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void*
 		if (target_type == TYPE_USER)
 		{
 			userrec* u = (userrec*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata);
+			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+u->uuid+" "+extname+" :"+extdata);
 		}
 		else if (target_type == TYPE_CHANNEL)
 		{
 			chanrec* c = (chanrec*)target;
-			s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata);
+			s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA "+c->name+" "+extname+" :"+extdata);
 		}
 	}
 	if (target_type == TYPE_OTHER)
 	{
-		s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata);
+		s->WriteLine(std::string(":")+ServerInstance->Config->GetSID()+" METADATA * "+extname+" :"+extdata);
 	}
 }
 
@@ -1170,7 +1350,7 @@ void ModuleSpanningTree::OnEvent(Event* event)
 		if (params->size() < 3)
 			return;
 		(*params)[2] = ":" + (*params)[2];
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"METADATA",*params);
 	}
 	else if (event->GetEventID() == "send_topic")
 	{
@@ -1179,7 +1359,7 @@ void ModuleSpanningTree::OnEvent(Event* event)
 		(*params)[1] = ":" + (*params)[1];
 		params->insert(params->begin() + 1,ServerInstance->Config->ServerName);
 		params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time(true)));
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC",*params);
 	}
 	else if (event->GetEventID() == "send_mode")
 	{
@@ -1187,10 +1367,18 @@ void ModuleSpanningTree::OnEvent(Event* event)
 			return;
 		// Insert the TS value of the object, either userrec or chanrec
 		time_t ourTS = 0;
+		std::string output_text;
+
+		/* Warning: in-place translation is only safe for type TR_NICK */
+		for (size_t n = 0; n < params->size(); n++)
+			ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]);
+
 		userrec* a = ServerInstance->FindNick((*params)[0]);
 		if (a)
 		{
 			ourTS = a->age;
+			Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params);
+			return;
 		}
 		else
 		{
@@ -1198,37 +1386,43 @@ void ModuleSpanningTree::OnEvent(Event* event)
 			if (a)
 			{
 				ourTS = a->age;
+				params->insert(params->begin() + 1,ConvToStr(ourTS));
+				Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",*params);
 			}
 		}
-		params->insert(params->begin() + 1,ConvToStr(ourTS));
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params);
 	}
 	else if (event->GetEventID() == "send_mode_explicit")
 	{
 		if (params->size() < 2)
 			return;
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params);
+		std::string output_text;
+
+		/* Warning: in-place translation is only safe for type TR_NICK */
+		for (size_t n = 0; n < params->size(); n++)
+			ServerInstance->Parser->TranslateUIDs(TR_NICK, (*params)[n], (*params)[n]);
+
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",*params);
 	}
 	else if (event->GetEventID() == "send_opers")
 	{
 		if (params->size() < 1)
 			return;
 		(*params)[0] = ":" + (*params)[0];
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"OPERNOTICE",*params);
 	}
 	else if (event->GetEventID() == "send_modeset")
 	{
 		if (params->size() < 2)
 			return;
 		(*params)[1] = ":" + (*params)[1];
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODENOTICE",*params);
 	}
 	else if (event->GetEventID() == "send_snoset")
 	{
 		if (params->size() < 2)
 			return;
 		(*params)[1] = ":" + (*params)[1];
-		Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params);
+		Utils->DoOneToMany(ServerInstance->Config->GetSID(),"SNONOTICE",*params);
 	}
 	else if (event->GetEventID() == "send_push")
 	{
@@ -1239,9 +1433,10 @@ void ModuleSpanningTree::OnEvent(Event* event)
 			
 		if (!a)
 			return;
-			
+
+		(*params)[0] = a->uuid;
 		(*params)[1] = ":" + (*params)[1];
-		Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server);
+		Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", *params, a->server);
 	}
 }
 
@@ -1252,6 +1447,8 @@ ModuleSpanningTree::~ModuleSpanningTree()
 	if (SyncTimer)
 		ServerInstance->Timers->DelTimer(SyncTimer);
 
+	ServerInstance->Timers->DelTimer(RefreshTimer);
+
 	ServerInstance->DoneWithInterface("InspSocketHook");
 }
 
@@ -1283,26 +1480,5 @@ Priority ModuleSpanningTree::Prioritize()
 	return PRIORITY_LAST;
 }
 
-class ModuleSpanningTreeFactory : public ModuleFactory
-{
- public:
-	ModuleSpanningTreeFactory()
-	{
-	}
-	
-	~ModuleSpanningTreeFactory()
-	{
-	}
-	
-	virtual Module * CreateModule(InspIRCd* Me)
-	{
-		return new ModuleSpanningTree(Me);
-	}
-	
-};
+MODULE_INIT(ModuleSpanningTree)
 
-
-extern "C" void * init_module( void )
-{
-	return new ModuleSpanningTreeFactory;
-}