X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Ftreesocket2.cpp;h=34cf318e30d9ec7488d445ca500d89db9b73f53a;hb=1211f840f16bacb21425eedba6794dfc8b39da40;hp=d287d4724f3f9ffdae14bdd492346b3d950d6eb4;hpb=343b92d82b6c9ce0415c26390ad2921c6d54ff67;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree/treesocket2.cpp b/src/modules/m_spanningtree/treesocket2.cpp
index d287d4724..34cf318e3 100644
--- a/src/modules/m_spanningtree/treesocket2.cpp
+++ b/src/modules/m_spanningtree/treesocket2.cpp
@@ -1,3 +1,17 @@
+/*       +------------------------------------+
+ *       | Inspire Internet Relay Chat Daemon |
+ *       +------------------------------------+
+ *
+ *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
+ *
+ * This program is free but copyrighted software; see
+ *            the file COPYING for details.
+ *
+ * ---------------------------------------------------
+ */
+
+#include "inspircd.h"
 #include "configreader.h"
 #include "users.h"
 #include "channels.h"
@@ -5,7 +19,6 @@
 #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"
@@ -21,23 +34,81 @@
 
 /* $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 */
 
+static std::map<std::string, std::string> warned;       /* Server names that have had protocol violation warnings displayed for them */
+
 int TreeSocket::WriteLine(std::string line)
 {
-	Instance->Log(DEBUG, "-> %s", line.c_str());
+	Instance->Log(DEBUG, "S[%d] -> %s", this->GetFd(), line.c_str());
 	line.append("\r\n");
 	return this->Write(line);
 }
 
+
 /* Handle ERROR command */
 bool TreeSocket::Error(std::deque<std::string> &params)
 {
 	if (params.size() < 1)
 		return false;
-	this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(InboundServerName != "" ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
+	this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
 	/* we will return false to cause the socket to close. */
 	return false;
 }
 
+bool TreeSocket::Modules(const std::string &prefix, std::deque<std::string> &params)
+{
+	if (params.empty())
+		return true;
+
+	if (!this->Instance->MatchText(this->Instance->Config->ServerName, params[0]))
+	{
+		/* Pass it on, not for us */
+		Utils->DoOneToOne(prefix, "MODULES", params, params[0]);
+		return true;
+	}
+
+	char strbuf[MAXBUF];
+	std::deque<std::string> par;
+	par.push_back(prefix);
+	par.push_back("");
+
+	userrec* source = this->Instance->FindNick(prefix);
+	if (!source)
+		return true;
+
+	for (unsigned int i = 0; i < Instance->Config->module_names.size(); i++)
+	{
+		Version V = Instance->modules[i]->GetVersion();
+		char modulename[MAXBUF];
+		char flagstate[MAXBUF];
+		*flagstate = 0;
+		if (V.Flags & VF_STATIC)
+			strlcat(flagstate,", static",MAXBUF);
+		if (V.Flags & VF_VENDOR)
+			strlcat(flagstate,", vendor",MAXBUF);
+		if (V.Flags & VF_COMMON)
+			strlcat(flagstate,", common",MAXBUF);
+		if (V.Flags & VF_SERVICEPROVIDER)
+			strlcat(flagstate,", service provider",MAXBUF);
+		if (!flagstate[0])
+			strcpy(flagstate,"  <no flags>");
+		strlcpy(modulename,Instance->Config->module_names[i].c_str(),256);
+		if (*source->oper)
+		{
+			snprintf(strbuf, MAXBUF, "::%s 900 %s :0x%08lx %d.%d.%d.%d %s (%s)",Instance->Config->ServerName,source->nick,(long unsigned int)Instance->modules[i],V.Major,V.Minor,V.Revision,V.Build,ServerConfig::CleanFilename(modulename),flagstate+2);
+		}
+		else
+		{
+			snprintf(strbuf, MAXBUF, "::%s 900 %s :%s",Instance->Config->ServerName,source->nick,ServerConfig::CleanFilename(modulename));
+		}
+		par[1] = strbuf;
+		Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server);
+	}
+	snprintf(strbuf, MAXBUF, "::%s 901 %s :End of MODULES list", Instance->Config->ServerName, source->nick);
+	par[1] = strbuf;
+	Utils->DoOneToOne(Instance->Config->ServerName, "PUSH", par, source->server);
+	return true;
+}
+
 /** remote MOTD. leet, huh? */
 bool TreeSocket::Motd(const std::string &prefix, std::deque<std::string> &params)
 {
@@ -71,7 +142,7 @@ bool TreeSocket::Motd(const std::string &prefix, std::deque<std::string> &params
 					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 				}
 
-				par[1] = std::string("::")+Instance->Config->ServerName+" 376 "+source->nick+" End of message of the day.";
+				par[1] = std::string("::")+Instance->Config->ServerName+" 376 "+source->nick+" :End of message of the day.";
 				Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 			}
 		}
@@ -174,7 +245,28 @@ bool TreeSocket::OperType(const std::string &prefix, std::deque<std::string> &pa
 		this->Instance->all_opers.push_back(u);
 		strlcpy(u->oper,opertype.c_str(),NICKMAX-1);
 		Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
-		this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str()));
+
+		TreeServer* remoteserver=Utils->FindServer(u->server);
+		bool dosend = true;
+
+		if (this->Utils->quiet_bursts)
+		{
+			/*
+			 * If quiet bursts are enabled, and server is bursting or silent uline (i.e. services),
+			 * then do nothing. -- w00t
+			 */
+			if (
+				this->bursting ||
+				Utils->FindRemoteBurstServer(remoteserver) ||
+				this->Instance->SilentULine(this->Instance->FindServerNamePtr(u->server))
+			   )
+			{
+				dosend = false;
+			}
+		}
+
+		if (dosend)
+			this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick,u->ident,u->host,irc::Spacify(opertype.c_str()));
 	}
 	return true;
 }
@@ -192,65 +284,42 @@ bool TreeSocket::ForceNick(const std::string &prefix, std::deque<std::string> &p
 	if (u)
 	{
 		Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix);
+
 		if (IS_LOCAL(u))
 		{
 			std::deque<std::string> par;
 			par.push_back(params[1]);
+
 			if (!u->ForceNickChange(params[1].c_str()))
 			{
-				userrec::QuitUser(this->Instance, u, "Nickname collision");
-				return true;
+				/* buh. UID them */
+				if (!u->ForceNickChange(u->uuid))
+				{
+					userrec::QuitUser(this->Instance, u, "Nickname collision");
+					return true;
+				}
 			}
+
 			u->age = atoi(params[2].c_str());
 		}
 	}
+
 	return true;
 }
 
-/*
- * Remote SQUIT (RSQUIT). Routing works similar to SVSNICK: Route it to the server that the target is connected to locally,
- * then let that server do the dirty work (squit it!). Example:
- * A -> B -> C -> D: oper on A squits D, A routes to B, B routes to C, C notices D connected locally, kills it. -- w00t
- */
-bool TreeSocket::RemoteSquit(const std::string &prefix, std::deque<std::string> &params)
+bool TreeSocket::OperQuit(const std::string &prefix, std::deque<std::string> &params)
 {
-	/* ok.. :w00t RSQUIT jupe.barafranca.com :reason here */
-	if (params.size() < 2)
+	if (params.size() < 1)
 		return true;
 
-	TreeServer* s = Utils->FindServerMask(params[0]);
-
-	if (s)
-	{
-		if (s == Utils->TreeRoot)
-		{
-			this->Instance->SNO->WriteToSnoMask('l',"What the fuck, I recieved a remote SQUIT for myself? :< (from %s", prefix.c_str());
-			return true;
-		}
-
-		TreeSocket* sock = s->GetSocket();
+	userrec* u = this->Instance->FindNick(prefix);
 
-		if (sock)
-		{
-			/* it's locally connected, KILL IT! */
-			Instance->SNO->WriteToSnoMask('l',"RSQUIT: Server \002%s\002 removed from network by %s: %s", params[0].c_str(), prefix.c_str(), params[1].c_str());
-			sock->Squit(s,"Server quit by " + prefix + ": " + params[1]);
-			Instance->SE->DelFd(sock);
-			sock->Close();
-			delete sock;
-		}
-		else
-		{
-			/* route the rsquit */
-			params[1] = ":" + params[1];
-			Utils->DoOneToOne(prefix, "RSQUIT", params, params[0]);
-		}
-	}
-	else
+	if (u)
 	{
-		/* mother fucker! it doesn't exist */
+		u->SetOperQuit(params[0]);
+		params[0] = ":" + params[0];
+		Utils->DoOneToAllButSender(prefix,"OPERQUIT",params,prefix);
 	}
-
 	return true;
 }
 
@@ -259,13 +328,16 @@ bool TreeSocket::ServiceJoin(const std::string &prefix, std::deque<std::string>
 	if (params.size() < 2)
 		return true;
 
+	if (!this->Instance->IsChannel(params[1].c_str()))
+		return true;
+
 	userrec* u = this->Instance->FindNick(params[0]);
 
 	if (u)
 	{
 		/* only join if it's local, otherwise just pass it on! */
 		if (IS_LOCAL(u))
-			chanrec::JoinUser(this->Instance, u, params[1].c_str(), false);
+			chanrec::JoinUser(this->Instance, u, params[1].c_str(), false, "", Instance->Time());
 		Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
 	}
 	return true;
@@ -290,30 +362,25 @@ bool TreeSocket::RemoteRehash(const std::string &prefix, std::deque<std::string>
 }
 
 bool TreeSocket::RemoteKill(const std::string &prefix, std::deque<std::string> &params)
-{
+{ 	 
 	if (params.size() != 2)
 		return true;
 
-	std::string nick = params[0];
-	userrec* u = this->Instance->FindNick(prefix);
-	userrec* who = this->Instance->FindNick(nick);
+	userrec* who = this->Instance->FindNick(params[0]);
 
 	if (who)
 	{
-		/* Prepend kill source, if we don't have one */
-		std::string sourceserv = prefix;
-		if (u)
-		{
-			sourceserv = u->server;
-		}
+		/* Prepend kill source, if we don't have one */ 	 
 		if (*(params[1].c_str()) != '[')
 		{
-			params[1] = "[" + sourceserv + "] Killed (" + params[1] +")";
+			params[1] = "[" + prefix + "] Killed (" + params[1] +")";
 		}
 		std::string reason = params[1];
 		params[1] = ":" + params[1];
-		Utils->DoOneToAllButSender(prefix,"KILL",params,sourceserv);
-		who->Write(":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str());
+		Utils->DoOneToAllButSender(prefix,"KILL",params,prefix);
+		// NOTE: This is safe with kill hiding on, as RemoteKill is only reached if we have a server prefix.
+		// in short this is not executed for USERS.
+		who->Write(":%s KILL %s :%s (%s)", prefix.c_str(), who->nick, prefix.c_str(), reason.c_str());
 		userrec::QuitUser(this->Instance,who,reason);
 	}
 	return true;
@@ -330,6 +397,10 @@ bool TreeSocket::LocalPong(const std::string &prefix, std::deque<std::string> &p
 		if (ServerSource)
 		{
 			ServerSource->SetPingFlag();
+			timeval t;
+			gettimeofday(&t, NULL);
+			long ts = (t.tv_sec * 1000) + (t.tv_usec / 1000);
+			ServerSource->rtt = ts - ServerSource->LastPingMsec;
 		}
 	}
 	else
@@ -363,11 +434,13 @@ bool TreeSocket::MetaData(const std::string &prefix, std::deque<std::string> &pa
 {
 	if (params.size() < 2)
 		return true;
-	else
+	else if (params.size() < 3)
 		params.push_back("");
 	TreeServer* ServerSource = Utils->FindServer(prefix);
 	if (ServerSource)
 	{
+		Utils->SetRemoteBursting(ServerSource, false);
+
 		if (params[0] == "*")
 		{
 			FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2]));
@@ -472,7 +545,8 @@ bool TreeSocket::AddLine(const std::string &prefix, std::deque<std::string> &par
 	{
 		if (atoi(params[4].c_str()))
 		{
-			this->Instance->SNO->WriteToSnoMask('x',"%s Added %cLINE on %s to expire in %lu seconds (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),atoi(params[4].c_str()),params[5].c_str());
+			time_t c_requires_crap = ConvToInt(params[4]) + Instance->Time();
+			this->Instance->SNO->WriteToSnoMask('x',"%s Added %cLINE on %s to expire on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),Instance->TimeString(c_requires_crap).c_str(),params[5].c_str());
 		}
 		else
 		{
@@ -519,19 +593,20 @@ bool TreeSocket::Whois(const std::string &prefix, std::deque<std::string> &param
 				userrec* x = this->Instance->FindNick(params[0]);
 				char signon[MAXBUF];
 				char idle[MAXBUF];
-				snprintf(signon,MAXBUF,"%lu",(unsigned long)x->signon);
-				snprintf(idle,MAXBUF,"%lu",(unsigned long)abs((x->idle_lastmsg)-Instance->Time(true)));
+				snprintf(signon, MAXBUF, "%lu", (unsigned long)x->signon);
+				snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((x->idle_lastmsg) - Instance->Time(true)));
 				std::deque<std::string> par;
 				par.push_back(prefix);
 				par.push_back(signon);
 				par.push_back(idle);
 				// ours, we're done, pass it BACK
-				Utils->DoOneToOne(params[0],"IDLE",par,u->server);
+				Utils->DoOneToOne(params[0], "IDLE", par, u->server);
 			}
 			else
 			{
 				// not ours pass it on
-				Utils->DoOneToOne(prefix,"IDLE",params,x->server);
+				if (x)
+					Utils->DoOneToOne(prefix, "IDLE", params, x->server);
 			}
 		}
 		else if (params.size() == 3)
@@ -545,12 +620,15 @@ bool TreeSocket::Whois(const std::string &prefix, std::deque<std::string> &param
 				unsigned long signon = atoi(params[1].c_str());
 				unsigned long idle = atoi(params[2].c_str());
 				if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
-					do_whois(this->Instance,who_to_send_to,u,signon,idle,nick_whoised.c_str());
+				{
+					do_whois(this->Instance, who_to_send_to, u, signon, idle, nick_whoised.c_str());
+				}
 			}
 			else
 			{
 				// not ours, pass it on
-				Utils->DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
+				if (who_to_send_to)
+					Utils->DoOneToOne(prefix, "IDLE", params, who_to_send_to->server);
 			}
 		}
 	}
@@ -587,28 +665,17 @@ bool TreeSocket::HandleSetTime(const std::string &prefix, std::deque<std::string
 	if ((params.size() == 2) && (params[1] == "FORCE"))
 		force = true;
 
-	time_t rts = atoi(params[0].c_str());
-	time_t us = Instance->Time(true);
+	time_t them = atoi(params[0].c_str());
+	time_t us = Instance->Time(false);
 
-	if (rts == us)
-	{
-		Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix);
-	}
-	else if (force || (rts < us))
-	{
-		int old = Instance->SetTimeDelta(rts - us);
-		Instance->Log(DEBUG, "%s TS (diff %d) from %s applied (old delta was %d)", (force) ? "Forced" : "Lower", rts - us, prefix.c_str(), old);
-
-		Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix);
-	}
-	else
-	{
-		Instance->Log(DEBUG, "Higher TS (diff %d) from %s overridden", us - rts, prefix.c_str());
+	time_t diff = them - us;
 
-		std::deque<std::string> oparams;
-		oparams.push_back(ConvToStr(us));
+	Utils->DoOneToAllButSender(prefix, "TIMESET", params, prefix);
 
-		Utils->DoOneToMany(prefix, "TIMESET", oparams);
+	if (force || (them != us))
+	{
+		time_t old = Instance->SetTimeDelta(diff);
+		Instance->Log(DEBUG, "TS (diff %d) from %s applied (old delta was %d)", diff, prefix.c_str(), old);
 	}
 
 	return true;
@@ -712,58 +779,98 @@ bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque<std::string>
 
 bool TreeSocket::RemoteServer(const std::string &prefix, std::deque<std::string> &params)
 {
-	if (params.size() < 4)
+	if (params.size() < 5)
 		return false;
 	std::string servername = params[0];
 	std::string password = params[1];
 	// hopcount is not used for a remote server, we calculate this ourselves
-	std::string description = params[3];
+	std::string sid = params[3];
+	std::string description = params[4];
 	TreeServer* ParentOfThis = Utils->FindServer(prefix);
 	if (!ParentOfThis)
 	{
-		this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix);
+		this->SendError("Protocol error - Introduced remote server from unknown server "+prefix);
 		return false;
 	}
 	TreeServer* CheckDupe = Utils->FindServer(servername);
 	if (CheckDupe)
 	{
-		this->WriteLine("ERROR :Server "+servername+" already exists!");
-		this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+servername+"\2 denied, already exists");
+		this->SendError("Server "+servername+" already exists!");
+		this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + prefix + "\2 denied, already exists. Closing link with " + prefix);
 		return false;
 	}
-	TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL);
+
+	Link* lnk = Utils->FindLink(servername);
+
+	TreeServer *Node = new TreeServer(this->Utils, this->Instance, servername, description, sid, ParentOfThis,NULL, lnk ? lnk->Hidden : false);
+
+	if (Node->DuplicateID())
+	{
+		this->SendError("Server ID "+sid+" already exists on the network!");
+		this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + prefix + "\2 denied, server ID already exists on the network. Closing link with " + prefix);
+		return false;
+	}
+
 	ParentOfThis->AddChild(Node);
-	params[3] = ":" + params[3];
+	params[4] = ":" + params[4];
+	Utils->SetRemoteBursting(Node, true);
 	Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix);
 	this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
 	return true;
 }
 
+bool TreeSocket::ComparePass(const std::string &ours, const std::string &theirs)
+{
+	if ((!strncmp(ours.c_str(), "HMAC-SHA256:", 12)) || (!strncmp(theirs.c_str(), "HMAC-SHA256:", 12)))
+	{
+		/* One or both of us specified hmac sha256, but we don't have sha256 module loaded!
+		 * We can't allow this password as valid.
+		 */
+		if (!Instance->FindModule("m_sha256.so") || !Utils->ChallengeResponse)
+				return false;
+		else
+			/* Straight string compare of hashes */
+			return ours == theirs;
+	}
+	else
+		/* Straight string compare of plaintext */
+		return ours == theirs;
+}
+
 bool TreeSocket::Outbound_Reply_Server(std::deque<std::string> &params)
 {
-	if (params.size() < 4)
+	if (params.size() < 5)
 		return false;
 
 	irc::string servername = params[0].c_str();
 	std::string sname = params[0];
 	std::string password = params[1];
+	std::string sid = params[3];
+	std::string description = params[4];
 	int hops = atoi(params[2].c_str());
 
+	this->InboundServerName = sname;
+	this->InboundDescription = description;
+	this->InboundSID = sid;
+
+	if (!sentcapab)
+		this->SendCapabilities();
+
 	if (hops)
 	{
-		this->WriteLine("ERROR :Server too far away for authentication");
+		this->SendError("Server too far away for authentication");
 		this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
 		return false;
 	}
-	std::string description = params[3];
+
 	for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 	{
-		if ((x->Name == servername) && (x->RecvPass == password))
+		if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password)) || (x->RecvPass == password && (this->GetTheirChallenge().empty()))))
 		{
 			TreeServer* CheckDupe = Utils->FindServer(sname);
 			if (CheckDupe)
 			{
-				this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+				this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
 				this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
 				return false;
 			}
@@ -775,44 +882,90 @@ bool TreeSocket::Outbound_Reply_Server(std::deque<std::string> &params)
 			// we should add the details of this server now
 			// to the servers tree, as a child of the root
 			// node.
-			TreeServer* Node = new TreeServer(this->Utils,this->Instance,sname,description,Utils->TreeRoot,this);
+
+			TreeServer *Node = new TreeServer(this->Utils, this->Instance, sname, description, sid, Utils->TreeRoot, this, x->Hidden);
+
+			if (Node->DuplicateID())
+			{
+				this->SendError("Server ID "+sid+" already exists on the network!");
+				this->Instance->SNO->WriteToSnoMask('l',"Server \2"+assign(servername)+"\2 being introduced denied, server ID already exists on the network. Closing link.");
+				return false;
+			}
+
 			Utils->TreeRoot->AddChild(Node);
-			params[3] = ":" + params[3];
+			params[4] = ":" + params[4];
 			Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname);
 			this->bursting = true;
 			this->DoBurst(Node);
 			return true;
 		}
 	}
-	this->WriteLine("ERROR :Invalid credentials");
+	this->SendError("Invalid credentials");
 	this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
 	return false;
 }
 
 bool TreeSocket::Inbound_Server(std::deque<std::string> &params)
 {
-	if (params.size() < 4)
+	if (params.size() < 5)
 		return false;
 	irc::string servername = params[0].c_str();
 	std::string sname = params[0];
 	std::string password = params[1];
+	std::string sid = params[3];
+	std::string description = params[4];
+	std::string OurSID;
 	int hops = atoi(params[2].c_str());
 
+	this->InboundServerName = sname;
+	this->InboundDescription = description;
+	this->InboundSID = sid;
+
+	OurSID += (char)((Instance->Config->sid / 100) + 48);
+	OurSID += (char)((Instance->Config->sid / 10) % 10 + 48);
+	OurSID += (char)(Instance->Config->sid % 10 + 48);
+
+	if (!sentcapab)
+		this->SendCapabilities();
+
 	if (hops)
 	{
-		this->WriteLine("ERROR :Server too far away for authentication");
+		this->SendError("Server too far away for authentication");
 		this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
 		return false;
 	}
-	std::string description = params[3];
+
 	for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 	{
-		if ((x->Name == servername) && (x->RecvPass == password))
+		if ((x->Name == servername) && ((ComparePass(this->MakePass(x->RecvPass,this->GetOurChallenge()),password) || x->RecvPass == password && (this->GetTheirChallenge().empty()))))
 		{
+			/* First check for instances of the server that are waiting between the inbound and outbound SERVER command */
+			TreeSocket* CheckDupeSocket = Utils->FindBurstingServer(sname);
+			if (CheckDupeSocket)
+			{
+				/* If we find one, we abort the link to prevent a race condition */
+				this->SendError("Negotiation collision");
+				this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists in a negotiating state.");
+				CheckDupeSocket->SendError("Negotiation collision");
+				Instance->SE->DelFd(CheckDupeSocket);
+				CheckDupeSocket->Close();
+				return false;
+			}
+			/* Check for fully initialized instances of the server by id */
+			Instance->Log(DEBUG,"Looking for dupe SID %s", sid.c_str());
+			TreeServer* CheckDupeSID = Utils->FindServerID(sid);
+			if (CheckDupeSID)
+			{
+				this->SendError("Server ID "+CheckDupeSID->GetID()+" already exists on server "+CheckDupeSID->GetName()+"!");
+				this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server ID '"+CheckDupeSID->GetID()+
+						"' already exists on server "+CheckDupeSID->GetName());
+				return false;
+			}
+			/* Now check for fully initialized instances of the server by name */
 			TreeServer* CheckDupe = Utils->FindServer(sname);
 			if (CheckDupe)
 			{
-				this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+				this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
 				this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
 				return false;
 			}
@@ -823,17 +976,17 @@ bool TreeSocket::Inbound_Server(std::deque<std::string> &params)
 				this->Instance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] using transport \2"+name+"\2");
 			}
 
-			this->InboundServerName = sname;
-			this->InboundDescription = description;
+			Utils->AddBurstingServer(sname,this);
+
 			// this is good. Send our details: Our server name and description and hopcount of 0,
 			// along with the sendpass from this block.
-			this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+x->SendPass+" 0 :"+this->Instance->Config->ServerDesc);
+			this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 "+OurSID+" :"+this->Instance->Config->ServerDesc);
 			// move to the next state, we are now waiting for THEM.
 			this->LinkState = WAIT_AUTH_2;
 			return true;
 		}
 	}
-	this->WriteLine("ERROR :Invalid credentials");
+	this->SendError("Invalid credentials");
 	this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
 	return false;
 }
@@ -843,8 +996,11 @@ void TreeSocket::Split(const std::string &line, std::deque<std::string> &n)
 	n.clear();
 	irc::tokenstream tokens(line);
 	std::string param;
-	while ((param = tokens.GetToken()) != "")
-		n.push_back(param);
+	while (tokens.GetToken(param))
+	{
+		if (!param.empty())
+			n.push_back(param);
+	}
 	return;
 }
 
@@ -859,10 +1015,13 @@ bool TreeSocket::ProcessLine(std::string &line)
 	if (line.empty())
 		return true;
 
-	Instance->Log(DEBUG, "<- %s", line.c_str());
+	Instance->Log(DEBUG, "S[%d] <- %s", this->GetFd(), line.c_str());
 
 	this->Split(line.c_str(),params);
-
+	
+	if (params.empty())
+		return true;
+	
 	if ((params[0][0] == ':') && (params.size() > 1))
 	{
 		prefix = params[0].substr(1);
@@ -894,23 +1053,17 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else if (command == "USER")
 			{
-				this->WriteLine("ERROR :Client connections to this port are prohibited.");
+				this->SendError("Client connections to this port are prohibited.");
 				return false;
 			}
 			else if (command == "CAPAB")
 			{
 				return this->Capab(params);
 			}
-			else if ((command == "U") || (command == "S"))
-			{
-				this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
-				return false;
-			}
 			else
 			{
-				std::string error("ERROR :Invalid command in negotiation phase: ");
-				error.append(command.c_str());
-				this->WriteLine(error);
+				irc::string error = "Invalid command in negotiation phase: " + command;
+				this->SendError(assign(error));
 				return false;
 			}
 		break;
@@ -923,48 +1076,49 @@ bool TreeSocket::ProcessLine(std::string &line)
 				// silently ignore.
 				return true;
 			}
-			else if ((command == "U") || (command == "S"))
-			{
-				this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
-				return false;
-			}
 			else if (command == "BURST")
 			{
 				if (params.size() && Utils->EnableTimeSync)
 				{
-					/* If a time stamp is provided, apply synchronization */
-					bool force = false;
+					bool we_have_delta = (Instance->Time(false) != Instance->Time(true));
 					time_t them = atoi(params[0].c_str());
-					time_t us = Instance->Time(false);
-					int delta = them - us;
-					if ((params.size() == 2) && (params[1] == "FORCE"))
-						force = true;
+					time_t delta = them - Instance->Time(false);
 					if ((delta < -600) || (delta > 600))
 					{
-						this->Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than ten minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta));
-						this->WriteLine("ERROR :Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than ten minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!");
+						Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta));
+						SendError("Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than five minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!");
 						return false;
 					}
+					else if ((delta < -30) || (delta > 30))
+					{
+						Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs(delta));
+					}
 
-					if (force || (us > them))
+					if (!Utils->MasterTime && !we_have_delta)
 					{
-						this->Instance->SetTimeDelta(them - us);
+						this->Instance->SetTimeDelta(delta);
 						// Send this new timestamp to any other servers
 						Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
 					}
-					else
-					{
-						// Override the timestamp
-						this->WriteLine(":" + Utils->TreeRoot->GetName() + " TIMESET " + ConvToStr(us));
-					}
 				}
 				this->LinkState = CONNECTED;
-				Node = new TreeServer(this->Utils,this->Instance,InboundServerName,InboundDescription,Utils->TreeRoot,this);
+				Link* lnk = Utils->FindLink(InboundServerName);
+
+				Node = new TreeServer(this->Utils,this->Instance, InboundServerName, InboundDescription, InboundSID, Utils->TreeRoot, this, lnk ? lnk->Hidden : false);
+
+				if (Node->DuplicateID())
+				{
+					this->SendError("Server ID "+InboundSID+" already exists on the network!");
+					this->Instance->SNO->WriteToSnoMask('l',"Server \2"+InboundServerName+"\2 being introduced from \2" + prefix + "\2 denied, server ID already exists on the network. Closing link.");
+					return false;
+				}
+				Utils->DelBurstingServer(this);
 				Utils->TreeRoot->AddChild(Node);
 				params.clear();
 				params.push_back(InboundServerName);
 				params.push_back("*");
 				params.push_back("1");
+				params.push_back(InboundSID);
 				params.push_back(":"+InboundDescription);
 				Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName);
 				this->bursting = true;
@@ -981,7 +1135,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 
 		break;
 		case LISTENER:
-			this->WriteLine("ERROR :Internal error -- listening socket accepted its own descriptor!!!");
+			this->SendError("Internal error -- listening socket accepted its own descriptor!!!");
 			return false;
 		break;
 		case CONNECTING:
@@ -998,20 +1152,26 @@ bool TreeSocket::ProcessLine(std::string &line)
 			{
 				return this->Error(params);
 			}
+			else if (command == "CAPAB")
+			{
+				return this->Capab(params);
+			}
 		break;
 		case CONNECTED:
 			// This is the 'authenticated' state, when all passwords
 			// have been exchanged and anything past this point is taken
 			// as gospel.
 
-			if (prefix != "")
+			if (!prefix.empty())
 			{
 				std::string direction = prefix;
-				userrec* t = this->Instance->FindNick(prefix);
+
+				userrec *t = this->Instance->FindUUID(prefix);
 				if (t)
 				{
 					direction = t->server;
 				}
+
 				TreeServer* route_back_again = Utils->BestRouteTo(direction);
 				if ((!route_back_again) || (route_back_again->GetSocket() != this))
 				{
@@ -1023,9 +1183,31 @@ bool TreeSocket::ProcessLine(std::string &line)
 				 * When there is activity on the socket, reset the ping counter so
 				 * that we're not wasting bandwidth pinging an active server.
 				 */
-				route_back_again->SetNextPingTime(time(NULL) + 60);
+				route_back_again->SetNextPingTime(time(NULL) + Utils->PingFreq);
 				route_back_again->SetPingFlag();
 			}
+			else
+			{
+				prefix = this->GetName();
+			}
+
+			if ((command == "MODE") && (params.size() >= 2))
+			{
+				chanrec* channel = Instance->FindChan(params[0]);
+				if (channel)
+				{
+					userrec* x = Instance->FindNick(prefix);
+					if (x)
+					{
+						if (warned.find(x->server) == warned.end())
+						{
+							Instance->Log(DEFAULT,"WARNING: I revceived modes '%s' from another server '%s'. This is not compliant with InspIRCd. Please check that server for bugs.", params[1].c_str(), x->server);
+							Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending nonstandard modes: '%s MODE %s' where FMODE should be used, and may cause desyncs.", x->server, x->nick, params[1].c_str());
+							warned[x->server] = x->nick;
+						}
+					}
+				}
+			}
 
 			if (command == "SVSMODE")
 			{
@@ -1035,16 +1217,19 @@ bool TreeSocket::ProcessLine(std::string &line)
 				 */
 				command = "MODE";
 			}
-			std::string target = "";
+			std::string target;
 			/* Yes, know, this is a mess. Its reasonably fast though as we're
 			 * working with std::string here.
 			 */
-			if ((command == "NICK") && (params.size() > 1))
+			if (command == "UID")
 			{
-				return this->IntroduceClient(prefix,params);
+				return this->ParseUID(prefix, params);
 			}
 			else if (command == "FJOIN")
 			{
+				TreeServer* ServerSource = Utils->FindServer(prefix);
+				if (ServerSource)
+					Utils->SetRemoteBursting(ServerSource, false);
 				return this->ForceJoin(prefix,params);
 			}
 			else if (command == "STATS")
@@ -1055,6 +1240,14 @@ bool TreeSocket::ProcessLine(std::string &line)
 			{
 				return this->Motd(prefix, params);
 			}
+			else if (command == "KILL" && Utils->IsServer(prefix))
+			{
+				return this->RemoteKill(prefix,params);
+			}
+			else if (command == "MODULES")
+			{
+				return this->Modules(prefix, params);
+			}
 			else if (command == "ADMIN")
 			{
 				return this->Admin(prefix, params);
@@ -1073,12 +1266,11 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else if (command == "FMODE")
 			{
+				TreeServer* ServerSource = Utils->FindServer(prefix);
+				if (ServerSource)
+					Utils->SetRemoteBursting(ServerSource, false);
 				return this->ForceMode(prefix,params);
 			}
-			else if (command == "KILL")
-			{
-				return this->RemoteKill(prefix,params);
-			}
 			else if (command == "FTOPIC")
 			{
 				return this->ForceTopic(prefix,params);
@@ -1097,40 +1289,46 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else if (command == "PING")
 			{
+				if (prefix.empty())
+					prefix = this->GetName();
 				/*
 				 * We just got a ping from a server that's bursting.
 				 * This can't be right, so set them to not bursting, and
 				 * apply their lines.
 				 */
+				TreeServer* ServerSource = Utils->FindServer(prefix);
+				if (ServerSource)
+					Utils->SetRemoteBursting(ServerSource, false);
+
 				if (this->bursting)
 				{
 					this->bursting = false;
 					Instance->XLines->apply_lines(Utils->lines_to_apply);
 					Utils->lines_to_apply = 0;
 				}
-				if (prefix == "")
-				{
-					prefix = this->GetName();
-				}
+
 				return this->LocalPing(prefix,params);
 			}
 			else if (command == "PONG")
 			{
+				if (prefix.empty())
+					prefix = this->GetName();
 				/*
 				 * We just got a pong from a server that's bursting.
 				 * This can't be right, so set them to not bursting, and
 				 * apply their lines.
 				 */
+				TreeServer* ServerSource = Utils->FindServer(prefix);
+				if (ServerSource)
+					Utils->SetRemoteBursting(ServerSource, false);
+
 				if (this->bursting)
 				{
 					this->bursting = false;
 					Instance->XLines->apply_lines(Utils->lines_to_apply);
 					Utils->lines_to_apply = 0;
 				}
-				if (prefix == "")
-				{
-					prefix = this->GetName();
-				}
+
 				return this->LocalPong(prefix,params);
 			}
 			else if (command == "VERSION")
@@ -1147,19 +1345,22 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else if (command == "ADDLINE")
 			{
+				TreeServer* ServerSource = Utils->FindServer(prefix);
+				if (ServerSource)
+					Utils->SetRemoteBursting(ServerSource, false);
 				return this->AddLine(prefix,params);
 			}
 			else if (command == "SVSNICK")
 			{
-				if (prefix == "")
+				if (prefix.empty())
 				{
 					prefix = this->GetName();
 				}
 				return this->ForceNick(prefix,params);
 			}
-			else if (command == "RSQUIT")
+			else if (command == "OPERQUIT")
 			{
-				return this->RemoteSquit(prefix, params);
+				return this->OperQuit(prefix,params);
 			}
 			else if (command == "IDLE")
 			{
@@ -1191,7 +1392,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 							delete chan;
 					}
 				}
-				if (this->InboundServerName != "")
+				if (!this->InboundServerName.empty())
 				{
 					sourceserv = this->InboundServerName;
 				}
@@ -1199,7 +1400,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else if (command == "SVSJOIN")
 			{
-				if (prefix == "")
+				if (prefix.empty())
 				{
 					prefix = this->GetName();
 				}
@@ -1216,7 +1417,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 			else if (command == "OPERNOTICE")
 			{
 				std::string sourceserv = this->myhost;
-				if (this->InboundServerName != "")
+				if (!this->InboundServerName.empty())
 					sourceserv = this->InboundServerName;
 				if (params.size() >= 1)
 					Instance->WriteOpers("*** From " + sourceserv + ": " + params[0]);
@@ -1225,7 +1426,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 			else if (command == "MODENOTICE")
 			{
 				std::string sourceserv = this->myhost;
-				if (this->InboundServerName != "")
+				if (!this->InboundServerName.empty())
 					sourceserv = this->InboundServerName;
 				if (params.size() >= 2)
 				{
@@ -1236,7 +1437,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 			else if (command == "SNONOTICE")
 			{
 				std::string sourceserv = this->myhost;
-				if (this->InboundServerName != "")
+				if (!this->InboundServerName.empty())
 					sourceserv = this->InboundServerName;
 				if (params.size() >= 2)
 				{
@@ -1250,10 +1451,8 @@ bool TreeSocket::ProcessLine(std::string &line)
 				Instance->XLines->apply_lines(Utils->lines_to_apply);
 				Utils->lines_to_apply = 0;
 				std::string sourceserv = this->myhost;
-				if (this->InboundServerName != "")
-				{
+				if (!this->InboundServerName.empty())
 					sourceserv = this->InboundServerName;
-				}
 				this->Instance->SNO->WriteToSnoMask('l',"Received end of netburst from \2%s\2",sourceserv.c_str());
 
 				Event rmode((char*)sourceserv.c_str(), (Module*)Utils->Creator, "new_server");
@@ -1263,12 +1462,14 @@ bool TreeSocket::ProcessLine(std::string &line)
 			}
 			else
 			{
-				// not a special inter-server command.
-				// Emulate the actual user doing the command,
-				// this saves us having a huge ugly parser.
-				userrec* who = this->Instance->FindNick(prefix);
+				/*
+				 * Not a special s2s command. Emulate the user doing it.
+				 * This saves us having a huge ugly command parser again.
+				 */
+				userrec *who = this->Instance->FindUUID(prefix);
+
 				std::string sourceserv = this->myhost;
-				if (this->InboundServerName != "")
+				if (!this->InboundServerName.empty())
 				{
 					sourceserv = this->InboundServerName;
 				}
@@ -1276,7 +1477,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 				{
 					if (Utils->IsServer(prefix))
 					{
-						const char* modelist[127];
+						const char* modelist[MAXPARAMETERS];
 						for (size_t i = 0; i < params.size(); i++)
 							modelist[i] = params[i].c_str();
 						userrec* fake = new userrec(Instance);
@@ -1301,11 +1502,11 @@ bool TreeSocket::ProcessLine(std::string &line)
 						{
 							std::deque<std::string> p;
 							p.push_back(params[0]);
-							p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")");
+							p.push_back(":Nickname collision ("+prefix+" -> "+params[0]+")");
 							Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
 							p.clear();
 							p.push_back(prefix);
-							p.push_back("Nickname collision");
+							p.push_back(":Nickname collision");
 							Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
 							userrec::QuitUser(this->Instance,x,"Nickname collision ("+prefix+" -> "+params[0]+")");
 							userrec* y = this->Instance->FindNick(prefix);
@@ -1326,7 +1527,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 					switch (this->Instance->CallCommandHandler(command.c_str(), strparams, params.size(), who))
 					{
 						case CMD_INVALID:
-							this->WriteLine("ERROR :Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules");
+							this->SendError("Unrecognised command '"+std::string(command.c_str())+"' -- possibly loaded mismatched modules");
 							return false;
 						break;
 						case CMD_FAILURE:
@@ -1357,7 +1558,7 @@ bool TreeSocket::ProcessLine(std::string &line)
 std::string TreeSocket::GetName()
 {
 	std::string sourceserv = this->myhost;
-	if (this->InboundServerName != "")
+	if (!this->InboundServerName.empty())
 	{
 		sourceserv = this->InboundServerName;
 	}
@@ -1368,7 +1569,7 @@ void TreeSocket::OnTimeout()
 {
 	if (this->LinkState == CONNECTING)
 	{
-		this->Instance->SNO->WriteToSnoMask('l',"CONNECT: Connection to \002"+myhost+"\002 timed out.");
+		Utils->Creator->RemoteMessage(NULL, "CONNECT: Connection to \002%s\002 timed out.", myhost.c_str());
 		Link* MyLink = Utils->FindLink(myhost);
 		if (MyLink)
 			Utils->DoFailOver(MyLink);
@@ -1377,11 +1578,14 @@ void TreeSocket::OnTimeout()
 
 void TreeSocket::OnClose()
 {
+	if (this->LinkState == LISTENER)
+		return;
+
 	// Connection closed.
 	// If the connection is fully up (state CONNECTED)
 	// then propogate a netsplit to all peers.
 	std::string quitserver = this->myhost;
-	if (this->InboundServerName != "")
+	if (!this->InboundServerName.empty())
 	{
 		quitserver = this->InboundServerName;
 	}
@@ -1391,8 +1595,13 @@ void TreeSocket::OnClose()
 		Squit(s,"Remote host closed the connection");
 	}
 
-	if (quitserver != "")
-		this->Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' failed.",quitserver.c_str());
+	if (!quitserver.empty())
+	{
+		Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' failed.",quitserver.c_str());
+		time_t server_uptime = Instance->Time() - this->age;	
+		if (server_uptime)
+			Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' was established for %s", quitserver.c_str(), Utils->Creator->TimeToStr(server_uptime).c_str());
+	}
 }
 
 int TreeSocket::OnIncomingConnection(int newsock, char* ip)
@@ -1412,7 +1621,7 @@ int TreeSocket::OnIncomingConnection(int newsock, char* ip)
 
 		if (!found)
 		{
-			this->Instance->SNO->WriteToSnoMask('l',"Server connection from %s denied (no link blocks with that IP address)", ip);
+			Utils->Creator->RemoteMessage(NULL,"Server connection from %s denied (no link blocks with that IP address)", ip);
 			close(newsock);
 			return false;
 		}