X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree.cpp;h=60eb650dd17748aa078a723db55f2b78a62a1e66;hb=5da606a02777de3d91f3b88d278ce49cadb67af5;hp=efd01b14130356cbd3aa3973aa3df7bfb8236ec6;hpb=855f0d98e90a077f46b456e98ebb8a9b290488f6;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp
index efd01b141..60eb650dd 100644
--- a/src/modules/m_spanningtree.cpp
+++ b/src/modules/m_spanningtree.cpp
@@ -16,8 +16,6 @@
 
 /* $ModDesc: Povides a spanning tree server link protocol */
 
-using namespace std;
-
 #include "configreader.h"
 #include "users.h"
 #include "channels.h"
@@ -28,16 +26,18 @@ using namespace std;
 #include "inspircd.h"
 #include "wildcard.h"
 #include "xline.h"
-#include "cull_list.h"
 #include "aes.h"
 
-#define nspace __gnu_cxx
-
-
 /** If you make a change which breaks the protocol, increment this.
  * If you  completely change the protocol, completely change the number.
+ *
+ * IMPORTANT: If you make changes, document your changes here, without fail:
+ * http://www.inspircd.org/wiki/List_of_protocol_changes_between_versions
+ *
+ * Failure to document your protocol changes will result in a painfully
+ * painful death by pain. You have been warned.
  */
-const long ProtocolVersion = 1101;
+const long ProtocolVersion = 1102;
 
 /*
  * The server list in InspIRCd is maintained as two structures
@@ -58,15 +58,7 @@ const long ProtocolVersion = 1101;
  * any O(n) lookups. If however, during a split or sync, we want
  * to apply an operation to a server, and any of its child objects
  * we can resort to recursion to walk the tree structure.
- */
-
-using irc::sockets::MatchCIDR;
-
-class ModuleSpanningTree;
-static ModuleSpanningTree* TreeProtocolModule;
-static InspIRCd* ServerInstance;
-
-/** Any socket can have one of five states at any one time.
+ * Any socket can have one of five states at any one time.
  * The LISTENER state indicates a socket which is listening
  * for connections. It cannot receive data itself, only incoming
  * sockets.
@@ -86,86 +78,130 @@ enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
 /* Foward declarations */
 class TreeServer;
 class TreeSocket;
-
-/* This variable represents the root of the server tree
- * (for all intents and purposes, it's us)
- */
-TreeServer *TreeRoot;
+class Link;
+class ModuleSpanningTree;
 
 /* This hash_map holds the hash equivalent of the server
  * tree, used for rapid linear lookups.
  */
 typedef nspace::hash_map<std::string, TreeServer*, nspace::hash<string>, irc::StrHashComp> server_hash;
-server_hash serverlist;
-
-typedef nspace::hash_map<std::string, userrec*> uid_hash;
-typedef nspace::hash_map<std::string, char*> sid_hash;
-
-/* More forward declarations */
-bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> &params, std::string target);
-bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> &params, std::string omit);
-bool DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> &params, std::string omit);
-bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> &params);
-bool DoOneToMany(const char* prefix, const char* command, std::deque<std::string> &params);
-bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque<std::string> &params);
-void ReadConfiguration(bool rebind);
-
-/* Flatten links and /MAP for non-opers */
-bool FlatLinks;
-/* Hide U-Lined servers in /MAP and /LINKS */
-bool HideULines;
-/* Announce TS changes to channels on merge */
-bool AnnounceTSChange;
-
-std::vector<std::string> ValidIPs;
-
-/** This will be used in a future version of InspIRCd for UID support
+
+typedef std::map<TreeServer*,TreeServer*> TreeServerList;
+
+/** The Link class might as well be a struct,
+ * but this is C++ and we don't believe in structs (!).
+ * It holds the entire information of one <link>
+ * tag from the main config file. We maintain a list
+ * of them, and populate the list on rehash/load.
  */
-class UserManager : public classbase
+class Link : public classbase
 {
-	uid_hash uids;
-	sid_hash sids;
  public:
-	UserManager()
-	{
-		uids.clear();
-		sids.clear();
-	}
-
-	std::string UserToUID(userrec* user)
-	{
-		return "";
-	}
-
-	std::string UIDToUser(const std::string &UID)
-	{
-		return "";
-	}
-
-	std::string CreateAndAdd(userrec* user)
-	{
-		return "";
-	}
-
-	std::string CreateAndAdd(const std::string &servername)
-	{
-		return "";
-	}
-
-	std::string ServerToSID(const std::string &servername)
-	{
-		return "";
-	}
+	irc::string Name;
+	std::string IPAddr;
+	int Port;
+	std::string SendPass;
+	std::string RecvPass;
+	unsigned long AutoConnect;
+	time_t NextConnectTime;
+	std::string EncryptionKey;
+	bool HiddenFromStats;
+	std::string FailOver;
+	int Timeout;
+};
 
-	std::string SIDToServer(const std::string &SID)
-	{
-		return "";
-	}
+/** Contains helper functions and variables for this module,
+ * and keeps them out of the global namespace
+ */
+class SpanningTreeUtilities
+{
+ private:
+	/** Creator server
+	 */
+	InspIRCd* ServerInstance;
+ public:
+	/** Creator module
+	 */
+	ModuleSpanningTree* Creator;
+	/** Flatten links and /MAP for non-opers
+	 */
+	bool FlatLinks;
+	/** Hide U-Lined servers in /MAP and /LINKS
+	 */
+	bool HideULines;
+	/** Announce TS changes to channels on merge
+	 */
+	bool AnnounceTSChange;
+	/** Synchronize timestamps between servers
+	 */
+	bool EnableTimeSync;
+	/** Socket bindings for listening sockets
+	 */
+	std::vector<TreeSocket*> Bindings;
+	/** This variable represents the root of the server tree
+	 */
+	TreeServer *TreeRoot;
+	/** IPs allowed to link to us
+	 */
+	std::vector<std::string> ValidIPs;
+	/** Hash of currently connected servers by name
+	 */
+	server_hash serverlist;
+	/** Holds the data from the <link> tags in the conf
+	 */
+	std::vector<Link> LinkBlocks;
 
-	userrec* FindByID(const std::string &UID)
-	{
-		return NULL;
-	}
+	/** Initialise utility class
+	 */
+	SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* Creator);
+	/** Destroy class and free listeners etc
+	 */
+	~SpanningTreeUtilities();
+	/** Send a message from this server to one other local or remote
+	 */
+	bool DoOneToOne(const std::string &prefix, const std::string &command, std::deque<std::string> &params, std::string target);
+	/** Send a message from this server to all but one other, local or remote
+	 */
+	bool DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque<std::string> &params, std::string omit);
+	/** Send a message from this server to all but one other, local or remote
+	 */
+	bool DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> &params, std::string omit);
+	/** Send a message from this server to all others
+	 */
+	bool DoOneToMany(const std::string &prefix, const std::string &command, std::deque<std::string> &params);
+	/** Send a message from this server to all others
+	 */
+	bool DoOneToMany(const char* prefix, const char* command, std::deque<std::string> &params);
+	/** Send a message from this server to all others, without doing any processing on the command (e.g. send it as-is with colons and all)
+	 */
+	bool DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque<std::string> &params);
+	/** Read the spanningtree module's tags from the config file
+	 */
+	void ReadConfiguration(bool rebind);
+	/** Add a server to the server list for GetListOfServersForChannel
+	 */
+	void AddThisServer(TreeServer* server, TreeServerList &list);
+	/** Compile a list of servers which contain members of channel c
+	 */
+	void GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list);
+	/** Find a server by name
+	 */
+	TreeServer* FindServer(const std::string &ServerName);
+	/** Find a route to a server by name
+	 */
+	TreeServer* BestRouteTo(const std::string &ServerName);
+	/** Find a server by glob mask
+	 */
+	TreeServer* FindServerMask(const std::string &ServerName);
+	/** Returns true if this is a server name we recognise
+	 */
+	bool IsServer(const std::string &ServerName);
+	/** Attempt to connect to the failover link of link x
+	 */
+	void DoFailOver(Link* x);
+	/** Find a link tag from a server name
+	 */
+	Link* FindLink(const std::string& name);
 };
 
 
@@ -197,13 +233,14 @@ class TreeServer : public classbase
 	TreeSocket* Socket;			/* For directly connected servers this points at the socket object */
 	time_t NextPing;			/* After this time, the server should be PINGed*/
 	bool LastPingWasGood;			/* True if the server responded to the last PING with a PONG */
+	SpanningTreeUtilities* Utils;		/* Utility class */
 	
  public:
 
 	/** We don't use this constructor. Its a dummy, and won't cause any insertion
 	 * of the TreeServer into the hash_map. See below for the two we DO use.
 	 */
-	TreeServer(InspIRCd* Instance) : ServerInstance(Instance)
+	TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance) : ServerInstance(Instance), Utils(Util)
 	{
 		Parent = NULL;
 		ServerName = "";
@@ -213,15 +250,16 @@ class TreeServer : public classbase
 		VersionString = ServerInstance->GetVersionString();
 	}
 
-	/** We use this constructor only to create the 'root' item, TreeRoot, which
+	/** We use this constructor only to create the 'root' item, Utils->TreeRoot, which
 	 * represents our own server. Therefore, it has no route, no parent, and
 	 * no socket associated with it. Its version string is our own local version.
 	 */
-	TreeServer(InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc)
+	TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc) : ServerInstance(Instance), ServerName(Name.c_str()), ServerDesc(Desc), Utils(Util)
 	{
 		Parent = NULL;
 		VersionString = "";
-		UserCount = OperCount = 0;
+		UserCount = ServerInstance->UserCount();
+		OperCount = ServerInstance->OperCount();
 		VersionString = ServerInstance->GetVersionString();
 		Route = NULL;
 		Socket = NULL; /* Fix by brain */
@@ -232,8 +270,8 @@ class TreeServer : public classbase
 	 * This constructor initializes the server's Route and Parent, and sets up
 	 * its ping counters so that it will be pinged one minute from now.
 	 */
-	TreeServer(InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock)
-		: ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock)
+	TreeServer(SpanningTreeUtilities* Util, InspIRCd* Instance, std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock)
+		: ServerInstance(Instance), Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock), Utils(Util)
 	{
 		VersionString = "";
 		UserCount = OperCount = 0;
@@ -265,13 +303,13 @@ class TreeServer : public classbase
 		 */
 
 		Route = Above;
-		if (Route == TreeRoot)
+		if (Route == Utils->TreeRoot)
 		{
 			Route = this;
 		}
 		else
 		{
-			while (this->Route->GetParent() != TreeRoot)
+			while (this->Route->GetParent() != Utils->TreeRoot)
 			{
 				this->Route = Route->GetParent();
 			}
@@ -322,10 +360,9 @@ class TreeServer : public classbase
 	 */
 	void AddHashEntry()
 	{
-		server_hash::iterator iter;
-		iter = serverlist.find(this->ServerName.c_str());
-		if (iter == serverlist.end())
-			serverlist[this->ServerName.c_str()] = this;
+		server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str());
+		if (iter == Utils->serverlist.end())
+			Utils->serverlist[this->ServerName.c_str()] = this;
 	}
 
 	/** This method removes the reference to this object
@@ -334,10 +371,9 @@ class TreeServer : public classbase
 	 */
 	void DelHashEntry()
 	{
-		server_hash::iterator iter;
-		iter = serverlist.find(this->ServerName.c_str());
-		if (iter != serverlist.end())
-			serverlist.erase(iter);
+		server_hash::iterator iter = Utils->serverlist.find(this->ServerName.c_str());
+		if (iter != Utils->serverlist.end())
+			Utils->serverlist.erase(iter);
 	}
 
 	/** These accessors etc should be pretty self-
@@ -414,7 +450,7 @@ class TreeServer : public classbase
 		return Parent;
 	}
 
-	void SetVersion(std::string Version)
+	void SetVersion(const std::string &Version)
 	{
 		VersionString = Version;
 	}
@@ -489,45 +525,13 @@ class TreeServer : public classbase
 	}
 };
 
-/** The Link class might as well be a struct,
- * but this is C++ and we don't believe in structs (!).
- * It holds the entire information of one <link>
- * tag from the main config file. We maintain a list
- * of them, and populate the list on rehash/load.
- */
-class Link : public classbase
-{
- public:
-	irc::string Name;
-	std::string IPAddr;
-	int Port;
-	std::string SendPass;
-	std::string RecvPass;
-	unsigned long AutoConnect;
-	time_t NextConnectTime;
-	std::string EncryptionKey;
-	bool HiddenFromStats;
-	irc::string FailOver;
-};
-
-void DoFailOver(Link* x);
-Link* FindLink(const std::string& name);
-
-/* The usual stuff for inspircd modules,
- * plus the vector of Link classes which we
- * use to store the <link> tags from the config
- * file.
- */
-ConfigReader *Conf;
-std::vector<Link> LinkBlocks;
-
 /** Yay for fast searches!
  * This is hundreds of times faster than recursion
  * or even scanning a linked list, especially when
  * there are more than a few servers to deal with.
  * (read as: lots).
  */
-TreeServer* FindServer(std::string ServerName)
+TreeServer* SpanningTreeUtilities::FindServer(const std::string &ServerName)
 {
 	server_hash::iterator iter;
 	iter = serverlist.find(ServerName.c_str());
@@ -547,7 +551,7 @@ TreeServer* FindServer(std::string ServerName)
  * See the comments for the constructor of TreeServer
  * for more details.
  */
-TreeServer* BestRouteTo(std::string ServerName)
+TreeServer* SpanningTreeUtilities::BestRouteTo(const std::string &ServerName)
 {
 	if (ServerName.c_str() == TreeRoot->GetName())
 		return NULL;
@@ -568,7 +572,7 @@ TreeServer* BestRouteTo(std::string ServerName)
  * and match each one until we get a hit. Yes its slow,
  * deal with it.
  */
-TreeServer* FindServerMask(std::string ServerName)
+TreeServer* SpanningTreeUtilities::FindServerMask(const std::string &ServerName)
 {
 	for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
 	{
@@ -579,7 +583,7 @@ TreeServer* FindServerMask(std::string ServerName)
 }
 
 /* A convenient wrapper that returns true if a server exists */
-bool IsServer(std::string ServerName)
+bool SpanningTreeUtilities::IsServer(const std::string &ServerName)
 {
 	return (FindServer(ServerName) != NULL);
 }
@@ -590,8 +594,9 @@ bool IsServer(std::string ServerName)
 class cmd_rconnect : public command_t
 {
 	Module* Creator;
+	SpanningTreeUtilities* Utils;
  public:
-	cmd_rconnect (InspIRCd* Instance, Module* Callback) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback)
+	cmd_rconnect (InspIRCd* Instance, Module* Callback, SpanningTreeUtilities* Util) : command_t(Instance, "RCONNECT", 'o', 2), Creator(Callback), Utils(Util)
 	{
 		this->source = "m_spanningtree.so";
 		syntax = "<remote-server-mask> <servermask>";
@@ -632,6 +637,7 @@ class cmd_rconnect : public command_t
  */
 class TreeSocket : public InspSocket
 {
+	SpanningTreeUtilities* Utils;
 	std::string myhost;
 	std::string in_buffer;
 	ServerState LinkState;
@@ -655,8 +661,8 @@ class TreeSocket : public InspSocket
 	 * most of the action, and append a few of our own values
 	 * to it.
 	 */
-	TreeSocket(InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime)
-		: InspSocket(SI, host, port, listening, maxtime)
+	TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime)
+		: InspSocket(SI, host, port, listening, maxtime), Utils(Util)
 	{
 		myhost = host;
 		this->LinkState = LISTENER;
@@ -664,8 +670,8 @@ class TreeSocket : public InspSocket
 		this->ctx_out = NULL;
 	}
 
-	TreeSocket(InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName)
-		: InspSocket(SI, host, port, listening, maxtime)
+	TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName)
+		: InspSocket(SI, host, port, listening, maxtime), Utils(Util)
 	{
 		myhost = ServerName;
 		this->LinkState = CONNECTING;
@@ -677,8 +683,8 @@ class TreeSocket : public InspSocket
 	 * we must associate it with a socket without creating a new
 	 * connection. This constructor is used for this purpose.
 	 */
-	TreeSocket(InspIRCd* SI, int newfd, char* ip)
-		: InspSocket(SI, newfd, ip)
+	TreeSocket(SpanningTreeUtilities* Util, InspIRCd* SI, int newfd, char* ip)
+		: InspSocket(SI, newfd, ip), Utils(Util)
 	{
 		this->LinkState = WAIT_AUTH_1;
 		this->ctx_in = NULL;
@@ -733,7 +739,7 @@ class TreeSocket : public InspSocket
 		if (this->LinkState == CONNECTING)
 		{
 			/* we do not need to change state here. */
-			for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+			for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 			{
 				if (x->Name == this->myhost)
 				{
@@ -775,9 +781,9 @@ class TreeSocket : public InspSocket
 		if (e == I_ERR_CONNECT)
 		{
 			this->Instance->SNO->WriteToSnoMask('l',"Connection failed: Connection to \002"+myhost+"\002 refused");
-			Link* MyLink = FindLink(myhost);
+			Link* MyLink = Utils->FindLink(myhost);
 			if (MyLink)
-				DoFailOver(MyLink);
+				Utils->DoFailOver(MyLink);
 		}
 	}
 
@@ -905,7 +911,7 @@ class TreeSocket : public InspSocket
 		return result;
 	}
 
-	bool Capab(std::deque<std::string> params)
+	bool Capab(const std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 		{
@@ -1058,15 +1064,18 @@ class TreeSocket : public InspSocket
 	 * does some validation first and passes on the SQUIT to all
 	 * other remaining servers.
 	 */
-	void Squit(TreeServer* Current,std::string reason)
+	void Squit(TreeServer* Current, const std::string &reason)
 	{
-		if ((Current) && (Current != TreeRoot))
+		if ((Current) && (Current != Utils->TreeRoot))
 		{
+			Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server");
+			rmode.Send(Instance);
+
 			std::deque<std::string> params;
 			params.push_back(Current->GetName());
 			params.push_back(":"+reason);
-			DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
-			if (Current->GetParent() == TreeRoot)
+			Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
+			if (Current->GetParent() == Utils->TreeRoot)
 			{
 				this->Instance->WriteOpers("Server \002"+Current->GetName()+"\002 split: "+reason);
 			}
@@ -1090,7 +1099,7 @@ class TreeSocket : public InspSocket
 	}
 
 	/** FMODE command - server mode with timestamp checks */
-	bool ForceMode(std::string source, std::deque<std::string> &params)
+	bool ForceMode(const std::string &source, std::deque<std::string> &params)
 	{
 		/* Chances are this is a 1.0 FMODE without TS */
 		if (params.size() < 3)
@@ -1308,7 +1317,7 @@ class TreeSocket : public InspSocket
 				newparams.push_back(ConvToStr(ourTS));
 				newparams.push_back(to_bounce+params_to_bounce);
 				Instance->Log(DEBUG,"BOUNCE BACK: %s",(to_bounce+params_to_bounce).c_str());
-				DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
+				Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
 			}
 
 			if (to_keep.length())
@@ -1339,7 +1348,7 @@ class TreeSocket : public InspSocket
 				}
 
 				/* HOT POTATO! PASS IT ON! */
-				DoOneToAllButSender(source,"FMODE",params,sourceserv);
+				Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv);
 			}
 		}
 		else
@@ -1448,7 +1457,7 @@ class TreeSocket : public InspSocket
 			/* Update the parameters for FMODE with the new 'bounced' string */
 			newparams[2] = modebounce;
 			/* Only send it back the way it came, no need to send it anywhere else */
-			DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
+			Utils->DoOneToOne(this->Instance->Config->ServerName,"FMODE",newparams,sourceserv);
 			Instance->Log(DEBUG,"FMODE bounced intelligently, our TS less than theirs and the other server is NOT a uline.");
 		}
 		else
@@ -1468,7 +1477,7 @@ class TreeSocket : public InspSocket
 				this->Instance->CallCommandHandler("MODE", modelist, n, who);
 
 			/* HOT POTATO! PASS IT ON! */
-			DoOneToAllButSender(source,"FMODE",params,sourceserv);
+			Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv);
 		}
 		/* Are we supposed to free the userrec? */
 		if (smode)
@@ -1478,7 +1487,7 @@ class TreeSocket : public InspSocket
 	}
 
 	/** FTOPIC command */
-	bool ForceTopic(std::string source, std::deque<std::string> &params)
+	bool ForceTopic(const std::string &source, std::deque<std::string> &params)
 	{
 		if (params.size() != 4)
 			return true;
@@ -1512,7 +1521,7 @@ class TreeSocket : public InspSocket
 					}
 					/* all done, send it on its way */
 					params[3] = ":" + params[3];
-					DoOneToAllButSender(source,"FTOPIC",params,nsource);
+					Utils->DoOneToAllButSender(source,"FTOPIC",params,nsource);
 				}
 			}
 			
@@ -1522,7 +1531,7 @@ class TreeSocket : public InspSocket
 	}
 
 	/** FJOIN, similar to TS6 SJOIN, but not quite. */
-	bool ForceJoin(std::string source, std::deque<std::string> &params)
+	bool ForceJoin(const std::string &source, std::deque<std::string> &params)
 	{
 		/* 1.1 FJOIN works as follows:
 		 *
@@ -1583,6 +1592,7 @@ class TreeSocket : public InspSocket
 		userrec* who = NULL;			/* User we are currently checking */
 		std::string channel = params[0];	/* Channel name, as a string */
 		time_t TS = atoi(params[1].c_str());	/* Timestamp given to us for remote side */
+		bool created = false;
 		
 		/* Try and find the channel */
 		chanrec* chan = this->Instance->FindChan(channel);
@@ -1593,11 +1603,13 @@ class TreeSocket : public InspSocket
 		/* default TS is a high value, which if we dont have this
 		 * channel will let the other side apply their modes.
 		 */
-		time_t ourTS = time(NULL)+600;
+		time_t ourTS = Instance->Time(true)+600;
 
 		/* Does this channel exist? if it does, get its REAL timestamp */
 		if (chan)
 			ourTS = chan->age;
+		else
+			created = true; /* don't perform deops, and set TS to correct time after processing. */
 
 		/* In 1.1, if they have the newer channel, we immediately clear
 		 * all status modes from our users. We then accept their modes.
@@ -1609,18 +1621,19 @@ class TreeSocket : public InspSocket
 		{
 			std::deque<std::string> param_list;
 
-			if (chan)
-				chan->age = TS;
-
 			/* Lower the TS here */
-			if (AnnounceTSChange && chan)
+			if (Utils->AnnounceTSChange && chan)
 				chan->WriteChannelWithServ(Instance->Config->ServerName,
-				"TS for %s changed from %lu to %lu", chan->name, ourTS, TS);
+				"NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS);
 			ourTS = TS;
-
 			param_list.push_back(channel);
-			/* Zap all the privilage modes on our side */
-			this->RemoveStatus(Instance->Config->ServerName, param_list);
+
+			/* Zap all the privilage modes on our side, if the channel exists here */
+			if (!created)
+			{
+				this->RemoveStatus(Instance->Config->ServerName, param_list);
+				chan->age = TS;
+			}
 		}
 
 		/* Put the final parameter of the FJOIN into a tokenstream ready to split it */
@@ -1631,7 +1644,7 @@ class TreeSocket : public InspSocket
 		 * if there is a TS collision.
 		 */
 		params[2] = ":" + params[2];
-		DoOneToAllButSender(source,"FJOIN",params,source);
+		Utils->DoOneToAllButSender(source,"FJOIN",params,source);
 
 		/* Now, process every 'prefixes,nick' pair */
 		while (item != "")
@@ -1698,7 +1711,7 @@ class TreeSocket : public InspSocket
 					 * the FJOIN may be different to the origin of the nicks
 					 * in the command itself.
 					 */
-					TreeServer* route_back_again = BestRouteTo(who->server);
+					TreeServer* route_back_again = Utils->BestRouteTo(who->server);
 					if ((!route_back_again) || (route_back_again->GetSocket() != this))
 					{
 						/* Oh dear oh dear. */
@@ -1793,6 +1806,20 @@ class TreeSocket : public InspSocket
 				free(mode_users[f]);
 		}
 
+		/* if we newly created the channel, set it's TS properly. */
+		if (created)
+		{
+			/* find created channel .. */
+			chan = this->Instance->FindChan(channel);
+			if (chan)
+				/* w00t said this shouldnt be needed but it is.
+				 * This isnt strictly true, as chan can be NULL
+				 * if a nick collision has occured and therefore
+				 * the channel was never created.
+				 */
+				chan->age = TS;
+		}
+
 		/* All done. That wasnt so bad was it, you can wipe
 		 * the sweat from your forehead now. :-)
 		 */
@@ -1800,7 +1827,7 @@ class TreeSocket : public InspSocket
 	}
 
 	/** NICK command */
-	bool IntroduceClient(std::string source, std::deque<std::string> &params)
+	bool IntroduceClient(const std::string &source, std::deque<std::string> &params)
 	{
 		if (params.size() < 8)
 			return true;
@@ -1859,17 +1886,17 @@ class TreeSocket : public InspSocket
 		this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString());
 
 		params[7] = ":" + params[7];
-		DoOneToAllButSender(source,"NICK",params,source);
+		Utils->DoOneToAllButSender(source,"NICK",params,source);
 
 		// Increment the Source Servers User Count..
-		TreeServer* SourceServer = FindServer(source);
+		TreeServer* SourceServer = Utils->FindServer(source);
 		if (SourceServer)
 		{
 			Instance->Log(DEBUG,"Found source server of %s",_new->nick);
 			SourceServer->AddUserCount();
 		}
 
-		FOREACH_MOD(I_OnPostConnect,OnPostConnect(_new));
+		FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new));
 
 		return true;
 	}
@@ -1880,6 +1907,8 @@ class TreeSocket : public InspSocket
 	 */
 	void SendFJoins(TreeServer* Current, chanrec* c)
 	{
+		std::string buffer;
+
 		Instance->Log(DEBUG,"Sending FJOINs to other server for %s",c->name);
 		char list[MAXBUF];
 		std::string individual_halfops = std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age);
@@ -1890,8 +1919,6 @@ class TreeSocket : public InspSocket
 		char* ptr = list + dlen;
 
 		CUList *ulist = c->GetUsers();
-		std::vector<userrec*> specific_halfop;
-		std::vector<userrec*> specific_voice;
 		std::string modes = "";
 		std::string params = "";
 
@@ -1907,7 +1934,8 @@ class TreeSocket : public InspSocket
 
 			if (curlen > (480-NICKMAX))
 			{
-				this->WriteLine(list);
+				buffer.append(list).append("\r\n");
+
 				dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",this->Instance->Config->ServerName,c->name,(unsigned long)c->age);
 				ptr = list + dlen;
 				ptrlen = 0;
@@ -1916,64 +1944,102 @@ class TreeSocket : public InspSocket
 		}
 
 		if (numusers)
-			this->WriteLine(list);
+			buffer.append(list).append("\r\n");
 
-                for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++)
-                {
+		/* Sorry for the hax. Because newly created channels assume +nt,
+		 * if this channel doesnt have +nt, explicitly send -n and -t for the missing modes.
+		 */
+		bool inverted = false;
+		if (!c->IsModeSet('n'))
+		{
+			modes.append("-n");
+			inverted = true;
+		}
+		if (!c->IsModeSet('t'))
+		{
+			modes.append("-t");
+			inverted = true;
+		}
+		if (inverted)
+		{
+			modes.append("+");
+		}
+
+		for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++)
+		{
 			modes.append("b");
-			params.append(b->data).append(" ");
-                }
-		this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+c->ChanModes(true)+modes+" "+params);
+			params.append(" ").append(b->data);
+
+			if (params.length() >= MAXMODES)
+			{
+				/* Wrap at MAXMODES */
+				buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n");
+				modes = "";
+				params = "";
+			}
+		}
+
+		buffer.append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(c->ChanModes(true));
+
+		/* Only send these if there are any */
+		if (!modes.empty())
+			buffer.append("\r\n").append(":").append(this->Instance->Config->ServerName).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params);
+
+		this->WriteLine(buffer);
 	}
 
 	/** Send G, Q, Z and E lines */
 	void SendXLines(TreeServer* Current)
 	{
 		char data[MAXBUF];
+		std::string buffer;
 		std::string n = this->Instance->Config->ServerName;
 		const char* sn = n.c_str();
 		int iterations = 0;
 		/* Yes, these arent too nice looking, but they get the job done */
 		for (std::vector<ZLine*>::iterator i = Instance->XLines->zlines.begin(); i != Instance->XLines->zlines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<QLine*>::iterator i = Instance->XLines->qlines.begin(); i != Instance->XLines->qlines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<GLine*>::iterator i = Instance->XLines->glines.begin(); i != Instance->XLines->glines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<ELine*>::iterator i = Instance->XLines->elines.begin(); i != Instance->XLines->elines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<ZLine*>::iterator i = Instance->XLines->pzlines.begin(); i != Instance->XLines->pzlines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s\r\n",sn,(*i)->ipaddr,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<QLine*>::iterator i = Instance->XLines->pqlines.begin(); i != Instance->XLines->pqlines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s\r\n",sn,(*i)->nick,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<GLine*>::iterator i = Instance->XLines->pglines.begin(); i != Instance->XLines->pglines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE G %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
 		for (std::vector<ELine*>::iterator i = Instance->XLines->pelines.begin(); i != Instance->XLines->pelines.end(); i++, iterations++)
 		{
-			snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
-			this->WriteLine(data);
+			snprintf(data,MAXBUF,":%s ADDLINE E %s@%s %s %lu %lu :%s\r\n",sn,(*i)->identmask,(*i)->hostmask,(*i)->source,(unsigned long)(*i)->set_time,(unsigned long)(*i)->duration,(*i)->reason);
+			buffer.append(data);
 		}
+
+		if (!buffer.empty())
+			this->WriteLine(buffer);
 	}
 
 	/** Send channel modes and topics */
@@ -1992,12 +2058,12 @@ class TreeSocket : public InspSocket
 				snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
 				this->WriteLine(data);
 			}
-			FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
+			FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)Utils->Creator,(void*)this));
 			list.clear();
 			c->second->GetExtList(list);
 			for (unsigned int j = 0; j < list.size(); j++)
 			{
-				FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
+				FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)Utils->Creator,(void*)this,list[j]));
 			}
 		}
 	}
@@ -2007,6 +2073,7 @@ class TreeSocket : public InspSocket
 	{
 		char data[MAXBUF];
 		std::deque<std::string> list;
+		std::string dataline;
 		int iterations = 0;
 		for (user_hash::iterator u = this->Instance->clientlist.begin(); u != this->Instance->clientlist.end(); u++, iterations++)
 		{
@@ -2016,18 +2083,20 @@ class TreeSocket : public InspSocket
 				this->WriteLine(data);
 				if (*u->second->oper)
 				{
-					this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
+					snprintf(data,MAXBUF,":%s OPERTYPE %s", u->second->nick, u->second->oper);
+					this->WriteLine(data);
 				}
 				if (*u->second->awaymsg)
 				{
-					this->WriteLine(":"+std::string(u->second->nick)+" AWAY :"+std::string(u->second->awaymsg));
+					snprintf(data,MAXBUF,":%s AWAY :%s", u->second->nick, u->second->awaymsg);
+					this->WriteLine(data);
 				}
-				FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)TreeProtocolModule,(void*)this));
+				FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this));
 				list.clear();
 				u->second->GetExtList(list);
 				for (unsigned int j = 0; j < list.size(); j++)
 				{
-					FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
+					FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j]));
 				}
 			}
 		}
@@ -2040,7 +2109,7 @@ class TreeSocket : public InspSocket
 	 */
 	void DoBurst(TreeServer* s)
 	{
-		std::string burst = "BURST "+ConvToStr(time(NULL));
+		std::string burst = "BURST "+ConvToStr(Instance->Time(true));
 		std::string endburst = "ENDBURST";
 		// Because by the end of the netburst, it  could be gone!
 		std::string name = s->GetName();
@@ -2049,13 +2118,13 @@ class TreeSocket : public InspSocket
 		/* send our version string */
 		this->WriteLine(std::string(":")+this->Instance->Config->ServerName+" VERSION :"+this->Instance->GetVersionString());
 		/* Send server tree */
-		this->SendServers(TreeRoot,s,1);
+		this->SendServers(Utils->TreeRoot,s,1);
 		/* Send users and their oper status */
 		this->SendUsers(s);
 		/* Send everything else (channel modes, xlines etc) */
 		this->SendChannelModes(s);
 		this->SendXLines(s);		
-		FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
+		FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this));
 		this->WriteLine(endburst);
 		this->Instance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2.");
 	}
@@ -2082,6 +2151,10 @@ class TreeSocket : public InspSocket
 			{
 				std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1);
 				in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n"));
+				/* Use rfind here not find, as theres more
+				 * chance of the \r being near the end of the
+				 * string, not the start.
+				 */
 				if (ret.find("\r") != std::string::npos)
 					ret = in_buffer.substr(0,in_buffer.find("\r")-1);
 				/* Process this one, abort if it
@@ -2101,14 +2174,22 @@ class TreeSocket : public InspSocket
 						{
 							ctx_in->Decrypt(out, result, nbytes, 0);
 							for (int t = 0; t < nbytes; t++)
-								if (result[t] == '\7') result[t] = 0;
+							{
+								if (result[t] == '\7')
+								{
+									/* We only need to stick a \0 on the
+									 * first \7, the rest will be lost
+									 */
+									result[t] = 0;
+									break;
+								}
+							}
 							ret = result;
 						}
 					}
 				}
 				if (!this->ProcessLine(ret))
 				{
-					Instance->Log(DEBUG,"ProcessLine says no!");
 					return false;
 				}
 			}
@@ -2139,7 +2220,8 @@ class TreeSocket : public InspSocket
 			to64frombits((unsigned char*)result64,(unsigned char*)result,ll);
 			line = result64;
 		}
-		return this->Write(line + "\r\n");
+		line.append("\r\n");
+		return this->Write(line);
 	}
 
 	/* Handle ERROR command */
@@ -2153,7 +2235,7 @@ class TreeSocket : public InspSocket
 	}
 
 	/** remote MOTD. leet, huh? */
-	bool Motd(std::string prefix, std::deque<std::string> &params)
+	bool Motd(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() > 0)
 		{
@@ -2172,21 +2254,21 @@ class TreeSocket : public InspSocket
 					if (!Instance->Config->MOTD.size())
 					{
 						par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing.";
-						DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+						Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 						return true;
 					}
    
 					par[1] = std::string("::")+Instance->Config->ServerName+" 375 "+source->nick+" :"+Instance->Config->ServerName+" message of the day";
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
    
 					for (unsigned int i = 0; i < Instance->Config->MOTD.size(); i++)
 					{
 						par[1] = std::string("::")+Instance->Config->ServerName+" 372 "+source->nick+" :- "+Instance->Config->MOTD[i];
-						DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+						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.";
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 				}
 			}
 			else
@@ -2194,14 +2276,14 @@ class TreeSocket : public InspSocket
 				/* Pass it on */
 				userrec* source = this->Instance->FindNick(prefix);
 				if (source)
-					DoOneToOne(prefix, "MOTD", params, params[0]);
+					Utils->DoOneToOne(prefix, "MOTD", params, params[0]);
 			}
 		}
 		return true;
 	}
 
 	/** remote ADMIN. leet, huh? */
-	bool Admin(std::string prefix, std::deque<std::string> &params)
+	bool Admin(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() > 0)
 		{
@@ -2218,16 +2300,16 @@ class TreeSocket : public InspSocket
 					par.push_back("");
 
 					par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName;
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 
 					par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name     - "+Instance->Config->AdminName;
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 
 					par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick;
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 
 					par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :E-Mail   - "+Instance->Config->AdminEmail;
-					DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+					Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 				}
 			}
 			else
@@ -2235,13 +2317,13 @@ class TreeSocket : public InspSocket
 				/* Pass it on */
 				userrec* source = this->Instance->FindNick(prefix);
 				if (source)
-					DoOneToOne(prefix, "ADMIN", params, params[0]);
+					Utils->DoOneToOne(prefix, "ADMIN", params, params[0]);
 			}
 		}
 		return true;
 	}
 
-	bool Stats(std::string prefix, std::deque<std::string> &params)
+	bool Stats(const std::string &prefix, std::deque<std::string> &params)
 	{
 		/* Get the reply to a STATS query if it matches this servername,
 		 * and send it back as a load of PUSH queries
@@ -2262,7 +2344,7 @@ class TreeSocket : public InspSocket
 					for (size_t i = 0; i < results.size(); i++)
 					{
 						par[1] = "::" + results[i];
-						DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
+						Utils->DoOneToOne(this->Instance->Config->ServerName, "PUSH",par, source->server);
 					}
 				}
 			}
@@ -2271,7 +2353,7 @@ class TreeSocket : public InspSocket
 				/* Pass it on */
 				userrec* source = this->Instance->FindNick(prefix);
 				if (source)
-					DoOneToOne(prefix, "STATS", params, params[1]);
+					Utils->DoOneToOne(prefix, "STATS", params, params[1]);
 			}
 		}
 		return true;
@@ -2281,7 +2363,7 @@ class TreeSocket : public InspSocket
 	/** Because the core won't let users or even SERVERS set +o,
 	 * we use the OPERTYPE command to do this.
 	 */
-	bool OperType(std::string prefix, std::deque<std::string> &params)
+	bool OperType(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() != 1)
 		{
@@ -2294,7 +2376,7 @@ class TreeSocket : public InspSocket
 		{
 			u->modes[UM_OPERATOR] = 1;
 			strlcpy(u->oper,opertype.c_str(),NICKMAX-1);
-			DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
+			Utils->DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
 		}
 		return true;
 	}
@@ -2302,7 +2384,7 @@ class TreeSocket : public InspSocket
 	/** Because Andy insists that services-compatible servers must
 	 * implement SVSNICK and SVSJOIN, that's exactly what we do :p
 	 */
-	bool ForceNick(std::string prefix, std::deque<std::string> &params)
+	bool ForceNick(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 3)
 			return true;
@@ -2311,14 +2393,14 @@ class TreeSocket : public InspSocket
 
 		if (u)
 		{
-			DoOneToAllButSender(prefix,"SVSNICK",params,prefix);
+			Utils->DoOneToAllButSender(prefix,"SVSNICK",params,prefix);
 			if (IS_LOCAL(u))
 			{
 				std::deque<std::string> par;
 				par.push_back(params[1]);
 				/* This is not required as one is sent in OnUserPostNick below
 				 */
-				//DoOneToMany(u->nick,"NICK",par);
+				//Utils->DoOneToMany(u->nick,"NICK",par);
 				if (!u->ForceNickChange(params[1].c_str()))
 				{
 					userrec::QuitUser(this->Instance, u, "Nickname collision");
@@ -2330,7 +2412,7 @@ class TreeSocket : public InspSocket
 		return true;
 	}
 
-	bool ServiceJoin(std::string prefix, std::deque<std::string> &params)
+	bool ServiceJoin(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 2)
 			return true;
@@ -2340,12 +2422,12 @@ class TreeSocket : public InspSocket
 		if (u)
 		{
 			chanrec::JoinUser(this->Instance, u, params[1].c_str(), false);
-			DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
+			Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
 		}
 		return true;
 	}
 
-	bool RemoteRehash(std::string prefix, std::deque<std::string> &params)
+	bool RemoteRehash(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return false;
@@ -2356,14 +2438,14 @@ class TreeSocket : public InspSocket
 		{
 			this->Instance->SNO->WriteToSnoMask('l',"Remote rehash initiated from server \002"+prefix+"\002.");
 			this->Instance->RehashServer();
-			ReadConfiguration(false);
-			InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance);
+			Utils->ReadConfiguration(false);
+			InitializeDisabledCommands(Instance->Config->DisabledCommands, Instance);
 		}
-		DoOneToAllButSender(prefix,"REHASH",params,prefix);
+		Utils->DoOneToAllButSender(prefix,"REHASH",params,prefix);
 		return true;
 	}
 
-	bool RemoteKill(std::string prefix, std::deque<std::string> &params)
+	bool RemoteKill(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() != 2)
 			return true;
@@ -2386,21 +2468,21 @@ class TreeSocket : public InspSocket
 			}
 			std::string reason = params[1];
 			params[1] = ":" + params[1];
-			DoOneToAllButSender(prefix,"KILL",params,sourceserv);
+			Utils->DoOneToAllButSender(prefix,"KILL",params,sourceserv);
 			who->Write(":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str());
 			userrec::QuitUser(this->Instance,who,reason);
 		}
 		return true;
 	}
 
-	bool LocalPong(std::string prefix, std::deque<std::string> &params)
+	bool LocalPong(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
 
 		if (params.size() == 1)
 		{
-			TreeServer* ServerSource = FindServer(prefix);
+			TreeServer* ServerSource = Utils->FindServer(prefix);
 			if (ServerSource)
 			{
 				ServerSource->SetPingFlag();
@@ -2427,19 +2509,19 @@ class TreeSocket : public InspSocket
 			else
 			{
 				// not for us, pass it on :)
-				DoOneToOne(prefix,"PONG",params,forwardto);
+				Utils->DoOneToOne(prefix,"PONG",params,forwardto);
 			}
 		}
 
 		return true;
 	}
 	
-	bool MetaData(std::string prefix, std::deque<std::string> &params)
+	bool MetaData(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 3)
 			return true;
 
-		TreeServer* ServerSource = FindServer(prefix);
+		TreeServer* ServerSource = Utils->FindServer(prefix);
 
 		if (ServerSource)
 		{
@@ -2466,27 +2548,27 @@ class TreeSocket : public InspSocket
 		}
 
 		params[2] = ":" + params[2];
-		DoOneToAllButSender(prefix,"METADATA",params,prefix);
+		Utils->DoOneToAllButSender(prefix,"METADATA",params,prefix);
 		return true;
 	}
 
-	bool ServerVersion(std::string prefix, std::deque<std::string> &params)
+	bool ServerVersion(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
 
-		TreeServer* ServerSource = FindServer(prefix);
+		TreeServer* ServerSource = Utils->FindServer(prefix);
 
 		if (ServerSource)
 		{
 			ServerSource->SetVersion(params[0]);
 		}
 		params[0] = ":" + params[0];
-		DoOneToAllButSender(prefix,"VERSION",params,prefix);
+		Utils->DoOneToAllButSender(prefix,"VERSION",params,prefix);
 		return true;
 	}
 
-	bool ChangeHost(std::string prefix, std::deque<std::string> &params)
+	bool ChangeHost(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
@@ -2496,12 +2578,12 @@ class TreeSocket : public InspSocket
 		if (u)
 		{
 			u->ChangeDisplayedHost(params[0].c_str());
-			DoOneToAllButSender(prefix,"FHOST",params,u->server);
+			Utils->DoOneToAllButSender(prefix,"FHOST",params,u->server);
 		}
 		return true;
 	}
 
-	bool AddLine(std::string prefix, std::deque<std::string> &params)
+	bool AddLine(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 6)
 			return true;
@@ -2548,7 +2630,7 @@ class TreeSocket : public InspSocket
 				this->Instance->SNO->WriteToSnoMask('x',"%s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str());
 			}
 			params[5] = ":" + params[5];
-			DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
+			Utils->DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
 		}
 		if (!this->bursting)
 		{
@@ -2558,7 +2640,7 @@ class TreeSocket : public InspSocket
 		return true;
 	}
 
-	bool ChangeName(std::string prefix, std::deque<std::string> &params)
+	bool ChangeName(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
@@ -2569,12 +2651,12 @@ class TreeSocket : public InspSocket
 		{
 			u->ChangeName(params[0].c_str());
 			params[0] = ":" + params[0];
-			DoOneToAllButSender(prefix,"FNAME",params,u->server);
+			Utils->DoOneToAllButSender(prefix,"FNAME",params,u->server);
 		}
 		return true;
 	}
 
-	bool Whois(std::string prefix, std::deque<std::string> &params)
+	bool Whois(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
@@ -2596,18 +2678,18 @@ class TreeSocket : public InspSocket
 					char idle[MAXBUF];
 
 					snprintf(signon,MAXBUF,"%lu",(unsigned long)x->signon);
-					snprintf(idle,MAXBUF,"%lu",(unsigned long)abs((x->idle_lastmsg)-time(NULL)));
+					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
-					DoOneToOne(params[0],"IDLE",par,u->server);
+					Utils->DoOneToOne(params[0],"IDLE",par,u->server);
 				}
 				else
 				{
 					// not ours pass it on
-					DoOneToOne(prefix,"IDLE",params,x->server);
+					Utils->DoOneToOne(prefix,"IDLE",params,x->server);
 				}
 			}
 			else if (params.size() == 3)
@@ -2626,14 +2708,14 @@ class TreeSocket : public InspSocket
 				else
 				{
 					// not ours, pass it on
-					DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
+					Utils->DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
 				}
 			}
 		}
 		return true;
 	}
 
-	bool Push(std::string prefix, std::deque<std::string> &params)
+	bool Push(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 2)
 			return true;
@@ -2651,12 +2733,51 @@ class TreeSocket : public InspSocket
 		{
 			// continue the raw onwards
 			params[1] = ":" + params[1];
-			DoOneToOne(prefix,"PUSH",params,u->server);
+			Utils->DoOneToOne(prefix,"PUSH",params,u->server);
 		}
 		return true;
 	}
 
-	bool Time(std::string prefix, std::deque<std::string> &params)
+	bool HandleSetTime(const std::string &prefix, std::deque<std::string> &params)
+	{
+		if (!params.size() || !Utils->EnableTimeSync)
+			return true;
+		
+		bool force = false;
+		
+		if ((params.size() == 2) && (params[1] == "FORCE"))
+			force = true;
+		
+		time_t rts = atoi(params[0].c_str());
+		time_t us = Instance->Time(true);
+		
+		if (rts == us)
+		{
+			Instance->Log(DEBUG, "Timestamp from %s is equal", prefix.c_str());
+			
+			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());
+			
+			std::deque<std::string> oparams;
+			oparams.push_back(ConvToStr(us));
+			
+			Utils->DoOneToMany(prefix, "TIMESET", oparams);
+		}
+		
+		return true;
+	}
+
+	bool Time(const std::string &prefix, std::deque<std::string> &params)
 	{
 		// :source.server TIME remote.server sendernick
 		// :remote.server TIME source.server sendernick TS
@@ -2668,11 +2789,9 @@ class TreeSocket : public InspSocket
 				userrec* u = this->Instance->FindNick(params[1]);
 				if (u)
 				{
-					char curtime[256];
-					snprintf(curtime,256,"%lu",(unsigned long)time(NULL));
-					params.push_back(curtime);
+					params.push_back(ConvToStr(Instance->Time(false)));
 					params[0] = prefix;
-					DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]);
+					Utils->DoOneToOne(this->Instance->Config->ServerName,"TIME",params,params[0]);
 				}
 			}
 			else
@@ -2680,7 +2799,7 @@ class TreeSocket : public InspSocket
 				// not us, pass it on
 				userrec* u = this->Instance->FindNick(params[1]);
 				if (u)
-					DoOneToOne(prefix,"TIME",params,params[0]);
+					Utils->DoOneToOne(prefix,"TIME",params,params[0]);
 			}
 		}
 		else if (params.size() == 3)
@@ -2700,13 +2819,13 @@ class TreeSocket : public InspSocket
 			else
 			{
 				if (u)
-					DoOneToOne(prefix,"TIME",params,u->server);
+					Utils->DoOneToOne(prefix,"TIME",params,u->server);
 			}
 		}
 		return true;
 	}
 	
-	bool LocalPing(std::string prefix, std::deque<std::string> &params)
+	bool LocalPing(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
@@ -2725,18 +2844,18 @@ class TreeSocket : public InspSocket
 				// this is a ping for us, send back PONG to the requesting server
 				params[1] = params[0];
 				params[0] = forwardto;
-				DoOneToOne(forwardto,"PONG",params,params[1]);
+				Utils->DoOneToOne(forwardto,"PONG",params,params[1]);
 			}
 			else
 			{
 				// not for us, pass it on :)
-				DoOneToOne(prefix,"PING",params,forwardto);
+				Utils->DoOneToOne(prefix,"PING",params,forwardto);
 			}
 			return true;
 		}
 	}
 
-	bool RemoveStatus(std::string prefix, std::deque<std::string> &params)
+	bool RemoveStatus(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 1)
 			return true;
@@ -2756,34 +2875,34 @@ class TreeSocket : public InspSocket
 				std::string modesequence = Instance->Modes->ModeString(i->second, c);
 				if (modesequence.length())
 				{
-					ServerInstance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str());
+					Instance->Log(DEBUG,"Mode sequence = '%s'",modesequence.c_str());
 					irc::spacesepstream sep(modesequence);
 					std::string modeletters = sep.GetToken();
-					ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
+					Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
 					
 					while (!modeletters.empty())
 					{
 						char mletter = *(modeletters.begin());
 						modestack.Push(mletter,sep.GetToken());
-						ServerInstance->Log(DEBUG,"Push letter = '%c'",mletter);
+						Instance->Log(DEBUG,"Push letter = '%c'",mletter);
 						modeletters.erase(modeletters.begin());
-						ServerInstance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
+						Instance->Log(DEBUG,"Mode letters = '%s'",modeletters.c_str());
 					}
 				}
 			}
 
 			while (modestack.GetStackedLine(stackresult))
 			{
-				ServerInstance->Log(DEBUG,"Stacked line size %d",stackresult.size());
+				Instance->Log(DEBUG,"Stacked line size %d",stackresult.size());
 				stackresult.push_front(ConvToStr(c->age));
 				stackresult.push_front(c->name);
-				DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult);
+				Utils->DoOneToMany(Instance->Config->ServerName, "FMODE", stackresult);
 				stackresult.erase(stackresult.begin() + 1);
-				ServerInstance->Log(DEBUG,"Stacked items:");
+				Instance->Log(DEBUG,"Stacked items:");
 				for (size_t z = 0; z < stackresult.size(); z++)
 				{
 					y[z] = stackresult[z].c_str();
-					ServerInstance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str());
+					Instance->Log(DEBUG,"\tstackresult[%d]='%s'",z,stackresult[z].c_str());
 				}
 				userrec* n = new userrec(Instance);
 				n->SetFd(FD_MAGIC_NUMBER);
@@ -2794,7 +2913,7 @@ class TreeSocket : public InspSocket
 		return true;
 	}
 
-	bool RemoteServer(std::string prefix, std::deque<std::string> &params)
+	bool RemoteServer(const std::string &prefix, std::deque<std::string> &params)
 	{
 		if (params.size() < 4)
 			return false;
@@ -2803,24 +2922,24 @@ class TreeSocket : public InspSocket
 		std::string password = params[1];
 		// hopcount is not used for a remote server, we calculate this ourselves
 		std::string description = params[3];
-		TreeServer* ParentOfThis = FindServer(prefix);
+		TreeServer* ParentOfThis = Utils->FindServer(prefix);
 
 		if (!ParentOfThis)
 		{
 			this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix);
 			return false;
 		}
-		TreeServer* CheckDupe = FindServer(servername);
+		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");
 			return false;
 		}
-		TreeServer* Node = new TreeServer(this->Instance,servername,description,ParentOfThis,NULL);
+		TreeServer* Node = new TreeServer(this->Utils,this->Instance,servername,description,ParentOfThis,NULL);
 		ParentOfThis->AddChild(Node);
 		params[3] = ":" + params[3];
-		DoOneToAllButSender(prefix,"SERVER",params,prefix);
+		Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix);
 		this->Instance->SNO->WriteToSnoMask('l',"Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
 		return true;
 	}
@@ -2842,11 +2961,11 @@ class TreeSocket : public InspSocket
 			return false;
 		}
 		std::string description = params[3];
-		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+		for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 		{
 			if ((x->Name == servername) && (x->RecvPass == password))
 			{
-				TreeServer* CheckDupe = FindServer(sname);
+				TreeServer* CheckDupe = Utils->FindServer(sname);
 				if (CheckDupe)
 				{
 					this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
@@ -2861,10 +2980,10 @@ class TreeSocket : public InspSocket
 				// 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->Instance,sname,description,TreeRoot,this);
-				TreeRoot->AddChild(Node);
+				TreeServer* Node = new TreeServer(this->Utils,this->Instance,sname,description,Utils->TreeRoot,this);
+				Utils->TreeRoot->AddChild(Node);
 				params[3] = ":" + params[3];
-				DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,sname);
+				Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,sname);
 				this->bursting = true;
 				this->DoBurst(Node);
 				return true;
@@ -2892,11 +3011,11 @@ class TreeSocket : public InspSocket
 			return false;
 		}
 		std::string description = params[3];
-		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+		for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 		{
 			if ((x->Name == servername) && (x->RecvPass == password))
 			{
-				TreeServer* CheckDupe = FindServer(sname);
+				TreeServer* CheckDupe = Utils->FindServer(sname);
 				if (CheckDupe)
 				{
 					this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
@@ -2929,7 +3048,7 @@ class TreeSocket : public InspSocket
 		return false;
 	}
 
-	void Split(std::string line, std::deque<std::string> &n)
+	void Split(const std::string &line, std::deque<std::string> &n)
 	{
 		n.clear();
 		irc::tokenstream tokens(line);
@@ -2939,17 +3058,17 @@ class TreeSocket : public InspSocket
 		return;
 	}
 
-	bool ProcessLine(std::string line)
+	bool ProcessLine(std::string &line)
 	{
 		std::deque<std::string> params;
 		irc::string command;
 		std::string prefix;
 		
+		line = line.substr(0, line.find_first_of("\r\n"));
+		
 		if (line.empty())
 			return true;
 		
-		line = line.substr(0, line.find_first_of("\r\n"));
-		
 		Instance->Log(DEBUG,"IN: %s", line.c_str());
 		
 		this->Split(line.c_str(),params);
@@ -2966,7 +3085,7 @@ class TreeSocket : public InspSocket
 		if ((!this->ctx_in) && (command == "AES"))
 		{
 			std::string sserv = params[0];
-			for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+			for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 			{
 				if ((x->EncryptionKey != "") && (x->Name == sserv))
 				{
@@ -3041,31 +3160,51 @@ class TreeSocket : public InspSocket
 				}
 				else if (command == "BURST")
 				{
-					if (params.size())
+					if (params.size() && Utils->EnableTimeSync)
 					{
-						/* If a time stamp is provided, try and check syncronization */
-						time_t THEM = atoi(params[0].c_str());
-						long delta = THEM-time(NULL);
+						/* If a time stamp is provided, apply synchronization */
+						bool force = false;
+						time_t them = atoi(params[0].c_str());
+						time_t us = Instance->Time(true);
+						int delta = them - us;
+
+						if ((params.size() == 2) && (params[1] == "FORCE"))
+							force = true;
+
 						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!");
 							return false;
 						}
-						else if ((delta < -60) || (delta > 60))
+						
+						if (us == them)
 						{
-							this->Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds, please consider synching your clocks.",abs(delta));
+							this->Instance->Log(DEBUG, "Timestamps are equal; pat yourself on the back");
+						}
+						else if (force || (us > them))
+						{
+							this->Instance->Log(DEBUG, "Remote server has lower TS (%d seconds)", them - us);
+							this->Instance->SetTimeDelta(them - us);
+							// Send this new timestamp to any other servers
+							Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
+						}
+						else
+						{
+							// Override the timestamp
+							this->Instance->Log(DEBUG, "We have a higher timestamp (by %d seconds), not updating delta", us - them);
+							this->WriteLine(":" + Utils->TreeRoot->GetName() + " TIMESET " + ConvToStr(us));
 						}
 					}
 					this->LinkState = CONNECTED;
-					Node = new TreeServer(this->Instance,InboundServerName,InboundDescription,TreeRoot,this);
-					TreeRoot->AddChild(Node);
+					Node = new TreeServer(this->Utils,this->Instance,InboundServerName,InboundDescription,Utils->TreeRoot,this);
+					Utils->TreeRoot->AddChild(Node);
 					params.clear();
 					params.push_back(InboundServerName);
 					params.push_back("*");
 					params.push_back("1");
 					params.push_back(":"+InboundDescription);
-					DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
+					Utils->DoOneToAllButSender(Utils->TreeRoot->GetName(),"SERVER",params,InboundServerName);
 					this->bursting = true;
 					this->DoBurst(Node);
 				}
@@ -3111,7 +3250,7 @@ class TreeSocket : public InspSocket
 					{
 						direction = t->server;
 					}
-					TreeServer* route_back_again = BestRouteTo(direction);
+					TreeServer* route_back_again = Utils->BestRouteTo(direction);
 					if ((!route_back_again) || (route_back_again->GetSocket() != this))
 					{
 						if (route_back_again)
@@ -3263,11 +3402,15 @@ class TreeSocket : public InspSocket
 				{
 					return this->Push(prefix,params);
 				}
+				else if (command == "TIMESET")
+				{
+					return this->HandleSetTime(prefix, params);
+				}
 				else if (command == "TIME")
 				{
 					return this->Time(prefix,params);
 				}
-				else if ((command == "KICK") && (IsServer(prefix)))
+				else if ((command == "KICK") && (Utils->IsServer(prefix)))
 				{
 					std::string sourceserv = this->myhost;
 					if (params.size() == 3)
@@ -3285,7 +3428,7 @@ class TreeSocket : public InspSocket
 					{
 						sourceserv = this->InboundServerName;
 					}
-					return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
+					return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
 				}
 				else if (command == "SVSJOIN")
 				{
@@ -3299,10 +3442,46 @@ class TreeSocket : public InspSocket
 				{
 					if (params.size() == 2)
 					{
-						this->Squit(FindServer(params[0]),params[1]);
+						this->Squit(Utils->FindServer(params[0]),params[1]);
 					}
 					return true;
 				}
+				else if (command == "OPERNOTICE")
+				{
+					std::string sourceserv = this->myhost;
+
+					if (this->InboundServerName != "")
+						sourceserv = this->InboundServerName;
+
+					if (params.size() >= 1)
+						Instance->WriteOpers("*** From " + sourceserv + ": " + params[0]);
+
+					return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params);
+				}
+				else if (command == "MODENOTICE")
+				{
+					std::string sourceserv = this->myhost;
+					if (this->InboundServerName != "")
+						sourceserv = this->InboundServerName;
+					if (params.size() >= 2)
+					{
+						Instance->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", sourceserv.c_str(), params[1].c_str());
+					}
+
+					return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params);
+				}
+				else if (command == "SNONOTICE")
+				{
+					std::string sourceserv = this->myhost;
+					if (this->InboundServerName != "")
+						sourceserv = this->InboundServerName;
+					if (params.size() >= 2)
+					{
+						Instance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + sourceserv + ": "+ params[1]);
+					}
+
+					return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params);
+				}
 				else if (command == "ENDBURST")
 				{
 					this->bursting = false;
@@ -3313,6 +3492,10 @@ class TreeSocket : public InspSocket
 						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");
+					rmode.Send(Instance);
+
 					return true;
 				}
 				else
@@ -3326,6 +3509,25 @@ class TreeSocket : public InspSocket
 					{
 						sourceserv = this->InboundServerName;
 					}
+					if ((!who) && (command == "MODE"))
+					{
+						if (Utils->IsServer(prefix))
+						{
+							const char* modelist[127];
+							for (size_t i = 0; i < params.size(); i++)
+								modelist[i] = params[i].c_str();
+
+							userrec* fake = new userrec(Instance);
+							fake->SetFd(FD_MAGIC_NUMBER);
+
+							this->Instance->SendMode(modelist, params.size(), fake);
+	
+							delete fake;
+
+							/* Hot potato! pass it on! */
+							return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
+						}
+					}
 					if (who)
 					{
 						if ((command == "NICK") && (params.size() > 0))
@@ -3340,18 +3542,18 @@ class TreeSocket : public InspSocket
 								std::deque<std::string> p;
 								p.push_back(params[0]);
 								p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")");
-								DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
+								Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
 								p.clear();
 								p.push_back(prefix);
 								p.push_back("Nickname collision");
-								DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
+								Utils->DoOneToMany(this->Instance->Config->ServerName,"KILL",p);
 								userrec::QuitUser(this->Instance,x,"Nickname collision ("+prefix+" -> "+params[0]+")");
 								userrec* y = this->Instance->FindNick(prefix);
 								if (y)
 								{
 									userrec::QuitUser(this->Instance,y,"Nickname collision");
 								}
-								return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
+								return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
 							}
 						}
 						// its a user
@@ -3378,7 +3580,7 @@ class TreeSocket : public InspSocket
 					else
 					{
 						// its not a user. Its either a server, or somethings screwed up.
-						if (IsServer(prefix))
+						if (Utils->IsServer(prefix))
 						{
 							target = this->Instance->Config->ServerName;
 						}
@@ -3388,7 +3590,7 @@ class TreeSocket : public InspSocket
 							return true;
 						}
 					}
-					return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
+					return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
 
 				}
 				return true;
@@ -3412,9 +3614,9 @@ class TreeSocket : public InspSocket
 		if (this->LinkState == CONNECTING)
 		{
 			this->Instance->SNO->WriteToSnoMask('l',"CONNECT: Connection to \002"+myhost+"\002 timed out.");
-			Link* MyLink = FindLink(myhost);
+			Link* MyLink = Utils->FindLink(myhost);
 			if (MyLink)
-				DoFailOver(MyLink);
+				Utils->DoFailOver(MyLink);
 		}
 	}
 
@@ -3428,12 +3630,14 @@ class TreeSocket : public InspSocket
 		{
 			quitserver = this->InboundServerName;
 		}
-		TreeServer* s = FindServer(quitserver);
+		TreeServer* s = Utils->FindServer(quitserver);
 		if (s)
 		{
 			Squit(s,"Remote host closed the connection");
 		}
-		this->Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' failed.",quitserver.c_str());
+
+		if (quitserver != "")
+			this->Instance->SNO->WriteToSnoMask('l',"Connection to '\2%s\2' failed.",quitserver.c_str());
 	}
 
 	virtual int OnIncomingConnection(int newsock, char* ip)
@@ -3444,11 +3648,11 @@ class TreeSocket : public InspSocket
 		 */
 		bool found = false;
 
-		found = (std::find(ValidIPs.begin(), ValidIPs.end(), ip) != ValidIPs.end());
+		found = (std::find(Utils->ValidIPs.begin(), Utils->ValidIPs.end(), ip) != Utils->ValidIPs.end());
 		if (!found)
 		{
-			for (vector<std::string>::iterator i = ValidIPs.begin(); i != ValidIPs.end(); i++)
-				if (MatchCIDR(ip, (*i).c_str()))
+			for (vector<std::string>::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++)
+				if (irc::sockets::MatchCIDR(ip, (*i).c_str()))
 					found = true;
 
 			if (!found)
@@ -3458,7 +3662,7 @@ class TreeSocket : public InspSocket
 				return false;
 			}
 		}
-		TreeSocket* s = new TreeSocket(this->Instance, newsock, ip);
+		TreeSocket* s = new TreeSocket(this->Utils, this->Instance, newsock, ip);
 		s = s; /* Whinge whinge whinge, thats all GCC ever does. */
 		return true;
 	}
@@ -3478,8 +3682,9 @@ class ServernameResolver : public Resolver
 	 * admin takes the tag away and rehashes while the domain is resolving.
 	 */
 	Link MyLink;
+	SpanningTreeUtilities* Utils;
  public: 
-	ServernameResolver(InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x)
+	ServernameResolver(Module* me, SpanningTreeUtilities* Util, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, me), MyLink(x), Utils(Util)
 	{
 		/* Nothing in here, folks */
 	}
@@ -3490,10 +3695,10 @@ class ServernameResolver : public Resolver
 		 * Passing a hostname directly to InspSocket causes it to
 		 * just bail and set its FD to -1.
 		 */
-		TreeServer* CheckDupe = FindServer(MyLink.Name.c_str());
+		TreeServer* CheckDupe = Utils->FindServer(MyLink.Name.c_str());
 		if (!CheckDupe) /* Check that nobody tried to connect it successfully while we were resolving */
 		{
-			TreeSocket* newsocket = new TreeSocket(ServerInstance, result,MyLink.Port,false,10,MyLink.Name.c_str());
+			TreeSocket* newsocket = new TreeSocket(this->Utils, ServerInstance, result,MyLink.Port,false,MyLink.Timeout ? MyLink.Timeout : 10,MyLink.Name.c_str());
 			if (newsocket->GetFd() > -1)
 			{
 				/* We're all OK */
@@ -3503,7 +3708,7 @@ class ServernameResolver : public Resolver
 				/* Something barfed, show the opers */
 				ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno));
 				delete newsocket;
-				DoFailOver(&MyLink);
+				Utils->DoFailOver(&MyLink);
 			}
 		}
 	}
@@ -3512,7 +3717,7 @@ class ServernameResolver : public Resolver
 	{
 		/* Ooops! */
 		ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str());
-		DoFailOver(&MyLink);
+		Utils->DoFailOver(&MyLink);
 	}
 };
 
@@ -3522,15 +3727,16 @@ class SecurityIPResolver : public Resolver
 {
  private:
 	Link MyLink;
+	SpanningTreeUtilities* Utils;
  public:
-	SecurityIPResolver(InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), MyLink(x)
+	SecurityIPResolver(Module* me, SpanningTreeUtilities* U, InspIRCd* Instance, const std::string &hostname, Link x) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, me), MyLink(x), Utils(U)
 	{
 	}
 
 	void OnLookupComplete(const std::string &result)
 	{
 		ServerInstance->Log(DEBUG,"Security IP cache: Adding IP address '%s' for Link '%s'",result.c_str(),MyLink.Name.c_str());
-		ValidIPs.push_back(result);
+		Utils->ValidIPs.push_back(result);
 	}
 
 	void OnError(ResolverError e, const std::string &errormessage)
@@ -3539,27 +3745,68 @@ class SecurityIPResolver : public Resolver
 	}
 };
 
-void AddThisServer(TreeServer* server, std::deque<TreeServer*> &list)
+SpanningTreeUtilities::SpanningTreeUtilities(InspIRCd* Instance, ModuleSpanningTree* C) : ServerInstance(Instance), Creator(C)
+{
+	Bindings.clear();
+	this->ReadConfiguration(true);
+	this->TreeRoot = new TreeServer(this, ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc);
+}
+
+SpanningTreeUtilities::~SpanningTreeUtilities()
 {
-	for (unsigned int c = 0; c < list.size(); c++)
+	for (unsigned int i = 0; i < Bindings.size(); i++)
+	{
+		ServerInstance->Log(DEBUG,"Freeing binding %d of %d",i, Bindings.size());
+		ServerInstance->SE->DelFd(Bindings[i]);
+		Bindings[i]->Close();
+		DELETE(Bindings[i]);
+	}
+	ServerInstance->Log(DEBUG,"Freeing connected servers...");
+	while (TreeRoot->ChildCount())
 	{
-		if (list[c] == server)
+		TreeServer* child_server = TreeRoot->GetChild(0);
+		ServerInstance->Log(DEBUG,"Freeing connected server %s", child_server->GetName().c_str());
+		if (child_server)
 		{
-			return;
+			TreeSocket* sock = child_server->GetSocket();
+			ServerInstance->SE->DelFd(sock);
+			sock->Close();
+			DELETE(sock);
 		}
 	}
-	list.push_back(server);
+	delete TreeRoot;
+}
+
+void SpanningTreeUtilities::AddThisServer(TreeServer* server, TreeServerList &list)
+{
+	if (list.find(server) == list.end())
+		list[server] = server;
 }
 
 /** returns a list of DIRECT servernames for a specific channel */
-void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
+void SpanningTreeUtilities::GetListOfServersForChannel(chanrec* c, TreeServerList &list, char status, const CUList &exempt_list)
 {
-	CUList *ulist = c->GetUsers();
+	CUList *ulist;
+	switch (status)
+	{
+		case '@':
+			ulist = c->GetOppedUsers();
+		break;
+		case '%':
+			ulist = c->GetHalfoppedUsers();
+		break;
+		case '+':
+			ulist = c->GetVoicedUsers();
+		break;
+		default:
+			ulist = c->GetUsers();
+		break;
+	}
 	for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
 	{
-		if (i->second->GetFd() < 0)
+		if ((i->second->GetFd() < 0) && (exempt_list.find(i->second) == exempt_list.end()))
 		{
-			TreeServer* best = BestRouteTo(i->second->server);
+			TreeServer* best = this->BestRouteTo(i->second->server);
 			if (best)
 				AddThisServer(best,list);
 		}
@@ -3567,9 +3814,10 @@ void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
 	return;
 }
 
-bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, irc::string command, std::deque<std::string> &params)
+bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque<std::string> &params)
 {
-	TreeServer* omitroute = BestRouteTo(omit);
+	char pfx = 0;
+	TreeServer* omitroute = this->BestRouteTo(omit);
 	if ((command == "NOTICE") || (command == "PRIVMSG"))
 	{
 		if (params.size() >= 2)
@@ -3577,6 +3825,7 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 			/* Prefixes */
 			if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+'))
 			{
+				pfx = params[0][0];
 				params[0] = params[0].substr(1, params[0].length()-1);
 			}
 			if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$'))
@@ -3588,7 +3837,7 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 					std::deque<std::string> par;
 					par.push_back(params[0]);
 					par.push_back(":"+params[1]);
-					DoOneToOne(prefix,command.c_str(),par,d->server);
+					this->DoOneToOne(prefix,command.c_str(),par,d->server);
 					return true;
 				}
 			}
@@ -3597,25 +3846,25 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 				std::deque<std::string> par;
 				par.push_back(params[0]);
 				par.push_back(":"+params[1]);
-				DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName());
+				this->DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName());
 				return true;
 			}
 			else
 			{
-				ServerInstance->Log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str());
 				chanrec* c = ServerInstance->FindChan(params[0]);
-				if (c)
+				userrec* u = ServerInstance->FindNick(prefix);
+				if (c && u)
 				{
-					std::deque<TreeServer*> list;
-					GetListOfServersForChannel(c,list);
-					ServerInstance->Log(DEBUG,"Got a list of %d servers",list.size());
-					unsigned int lsize = list.size();
-					for (unsigned int i = 0; i < lsize; i++)
+					CUList elist;
+					TreeServerList list;
+					FOREACH_MOD(I_OnBuildExemptList, OnBuildExemptList((command == "PRIVMSG" ? MSG_PRIVMSG : MSG_NOTICE), c, u, pfx, elist));
+					GetListOfServersForChannel(c,list,pfx,elist);
+
+					for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
 					{
-						TreeSocket* Sock = list[i]->GetSocket();
-						if ((Sock) && (list[i]->GetName() != omit) && (omitroute != list[i]))
+						TreeSocket* Sock = i->second->GetSocket();
+						if ((Sock) && (i->second->GetName() != omit) && (omitroute != i->second))
 						{
-							ServerInstance->Log(DEBUG,"Writing privmsg to server %s",list[i]->GetName().c_str());
 							Sock->WriteLine(data);
 						}
 					}
@@ -3624,10 +3873,10 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 			}
 		}
 	}
-	unsigned int items = TreeRoot->ChildCount();
+	unsigned int items =this->TreeRoot->ChildCount();
 	for (unsigned int x = 0; x < items; x++)
 	{
-		TreeServer* Route = TreeRoot->GetChild(x);
+		TreeServer* Route = this->TreeRoot->GetChild(x);
 		if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
 		{
 			TreeSocket* Sock = Route->GetSocket();
@@ -3638,19 +3887,19 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 	return true;
 }
 
-bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> &params, std::string omit)
+bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque<std::string> &params, std::string omit)
 {
-	TreeServer* omitroute = BestRouteTo(omit);
+	TreeServer* omitroute = this->BestRouteTo(omit);
 	std::string FullLine = ":" + prefix + " " + command;
 	unsigned int words = params.size();
 	for (unsigned int x = 0; x < words; x++)
 	{
 		FullLine = FullLine + " " + params[x];
 	}
-	unsigned int items = TreeRoot->ChildCount();
+	unsigned int items = this->TreeRoot->ChildCount();
 	for (unsigned int x = 0; x < items; x++)
 	{
-		TreeServer* Route = TreeRoot->GetChild(x);
+		TreeServer* Route = this->TreeRoot->GetChild(x);
 		// Send the line IF:
 		// The route has a socket (its a direct connection)
 		// The route isnt the one to be omitted
@@ -3665,7 +3914,7 @@ bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std
 	return true;
 }
 
-bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> &params)
+bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, std::deque<std::string> &params)
 {
 	std::string FullLine = ":" + prefix + " " + command;
 	unsigned int words = params.size();
@@ -3673,10 +3922,10 @@ bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string
 	{
 		FullLine = FullLine + " " + params[x];
 	}
-	unsigned int items = TreeRoot->ChildCount();
+	unsigned int items = this->TreeRoot->ChildCount();
 	for (unsigned int x = 0; x < items; x++)
 	{
-		TreeServer* Route = TreeRoot->GetChild(x);
+		TreeServer* Route = this->TreeRoot->GetChild(x);
 		if (Route && Route->GetSocket())
 		{
 			TreeSocket* Sock = Route->GetSocket();
@@ -3687,23 +3936,23 @@ bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string
 	return true;
 }
 
-bool DoOneToMany(const char* prefix, const char* command, std::deque<std::string> &params)
+bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, std::deque<std::string> &params)
 {
 	std::string spfx = prefix;
 	std::string scmd = command;
-	return DoOneToMany(spfx, scmd, params);
+	return this->DoOneToMany(spfx, scmd, params);
 }
 
-bool DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> &params, std::string omit)
+bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> &params, std::string omit)
 {
 	std::string spfx = prefix;
 	std::string scmd = command;
-	return DoOneToAllButSender(spfx, scmd, params, omit);
+	return this->DoOneToAllButSender(spfx, scmd, params, omit);
 }
-
-bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> &params, std::string target)
+	
+bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, std::deque<std::string> &params, std::string target)
 {
-	TreeServer* Route = BestRouteTo(target);
+	TreeServer* Route = this->BestRouteTo(target);
 	if (Route)
 	{
 		std::string FullLine = ":" + prefix + " " + command;
@@ -3726,44 +3975,47 @@ bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string>
 	}
 }
 
-std::vector<TreeSocket*> Bindings;
-
-void ReadConfiguration(bool rebind)
+void SpanningTreeUtilities::ReadConfiguration(bool rebind)
 {
-	Conf = new ConfigReader(ServerInstance);
+	ConfigReader* Conf = new ConfigReader(ServerInstance);
 	if (rebind)
 	{
 		for (int j =0; j < Conf->Enumerate("bind"); j++)
 		{
 			std::string Type = Conf->ReadValue("bind","type",j);
 			std::string IP = Conf->ReadValue("bind","address",j);
-			int Port = Conf->ReadInteger("bind","port",j,true);
+			std::string Port = Conf->ReadValue("bind","port",j);
 			if (Type == "servers")
 			{
-				ServerInstance->Log(DEBUG,"m_spanningtree: Binding server port %s:%d", IP.c_str(), Port);
-				if (IP == "*")
-				{
-					IP = "";
-				}
-				TreeSocket* listener = new TreeSocket(ServerInstance, IP.c_str(),Port,true,10);
-				if (listener->GetState() == I_LISTENING)
-				{
-					ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), Port);
-					Bindings.push_back(listener);
-				}
-				else
+				irc::portparser portrange(Port, false);
+				int portno = -1;
+				while ((portno = portrange.GetToken()))
 				{
-					ServerInstance->Log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port);
-					listener->Close();
-					DELETE(listener);
+					ServerInstance->Log(DEBUG,"m_spanningtree: Binding server port %s:%d", IP.c_str(), portno);
+					if (IP == "*")
+						IP = "";
+
+					TreeSocket* listener = new TreeSocket(this, ServerInstance, IP.c_str(), portno, true, 10);
+					if (listener->GetState() == I_LISTENING)
+					{
+						ServerInstance->Log(DEFAULT,"m_spanningtree: Binding server port %s:%d successful!", IP.c_str(), portno);
+						Bindings.push_back(listener);
+					}
+					else
+					{
+						ServerInstance->Log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %s:%d",IP.c_str(), portno);
+						listener->Close();
+						DELETE(listener);
+					}
+					ServerInstance->Log(DEBUG,"Done with this binding");
 				}
-				ServerInstance->Log(DEBUG,"Done with this binding");
 			}
 		}
 	}
 	FlatLinks = Conf->ReadFlag("options","flatlinks",0);
 	HideULines = Conf->ReadFlag("options","hideulines",0);
 	AnnounceTSChange = Conf->ReadFlag("options","announcets",0);
+	EnableTimeSync = !(Conf->ReadFlag("options","notimesync",0));
 	LinkBlocks.clear();
 	ValidIPs.clear();
 	for (int j =0; j < Conf->Enumerate("link"); j++)
@@ -3779,6 +4031,7 @@ void ReadConfiguration(bool rebind)
 		L.AutoConnect = Conf->ReadInteger("link","autoconnect",j,true);
 		L.EncryptionKey =  Conf->ReadValue("link","encryptionkey",j);
 		L.HiddenFromStats = Conf->ReadFlag("link","hidden",j);
+		L.Timeout = Conf->ReadInteger("link","timeout",j,true);
 		L.NextConnectTime = time(NULL) + L.AutoConnect;
 		/* Bugfix by brain, do not allow people to enter bad configurations */
 		if (L.Name != ServerInstance->Config->ServerName)
@@ -3796,7 +4049,7 @@ void ReadConfiguration(bool rebind)
 				{
 					try
 					{
-						SecurityIPResolver* sr = new SecurityIPResolver(ServerInstance, L.IPAddr, L);
+						SecurityIPResolver* sr = new SecurityIPResolver((Module*)this->Creator, this, ServerInstance, L.IPAddr, L);
 						ServerInstance->AddResolver(sr);
 					}
 					catch (ModuleException& e)
@@ -3840,6 +4093,19 @@ void ReadConfiguration(bool rebind)
 	DELETE(Conf);
 }
 
+/** To create a timer which recurs every second, we inherit from InspTimer.
+ * InspTimer is only one-shot however, so at the end of each Tick() we simply
+ * insert another of ourselves into the pending queue :)
+ */
+class TimeSyncTimer : public InspTimer
+{
+ private:
+	InspIRCd *Instance;
+	ModuleSpanningTree *Module;
+ public:
+	TimeSyncTimer(InspIRCd *Instance, ModuleSpanningTree *Mod);
+	virtual void Tick(time_t TIME);
+};
 
 class ModuleSpanningTree : public Module
 {
@@ -3848,36 +4114,38 @@ class ModuleSpanningTree : public Module
 	unsigned int max_local;
 	unsigned int max_global;
 	cmd_rconnect* command_rconnect;
+	SpanningTreeUtilities* Utils;
 
  public:
+	TimeSyncTimer *SyncTimer;
 
 	ModuleSpanningTree(InspIRCd* Me)
 		: Module::Module(Me), max_local(0), max_global(0)
 	{
-		
-		Bindings.clear();
-
-		::ServerInstance = Me;
+		Utils = new SpanningTreeUtilities(Me, this);
 
-		// Create the root of the tree
-		TreeRoot = new TreeServer(ServerInstance, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc);
-
-		ReadConfiguration(true);
-
-		command_rconnect = new cmd_rconnect(ServerInstance, this);
+		command_rconnect = new cmd_rconnect(ServerInstance, this, Utils);
 		ServerInstance->AddCommand(command_rconnect);
+
+		if (Utils->EnableTimeSync)
+		{
+			SyncTimer = new TimeSyncTimer(ServerInstance, this);
+			ServerInstance->Timers->AddTimer(SyncTimer);
+		}
+		else
+			SyncTimer = NULL;
 	}
 
 	void ShowLinks(TreeServer* Current, userrec* user, int hops)
 	{
-		std::string Parent = TreeRoot->GetName();
+		std::string Parent = Utils->TreeRoot->GetName();
 		if (Current->GetParent())
 		{
 			Parent = Current->GetParent()->GetName();
 		}
 		for (unsigned int q = 0; q < Current->ChildCount(); q++)
 		{
-			if ((HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
+			if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
 			{
 				if (*user->oper)
 				{
@@ -3890,24 +4158,24 @@ class ModuleSpanningTree : public Module
 			}
 		}
 		/* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
-		if ((HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper))
+		if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper))
 			return;
-		user->WriteServ("364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(FlatLinks && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(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 && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(Utils->FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
 	}
 
 	int CountLocalServs()
 	{
-		return TreeRoot->ChildCount();
+		return Utils->TreeRoot->ChildCount();
 	}
 
 	int CountServs()
 	{
-		return serverlist.size();
+		return Utils->serverlist.size();
 	}
 
 	void HandleLinks(const char** parameters, int pcnt, userrec* user)
 	{
-		ShowLinks(TreeRoot,user,0);
+		ShowLinks(Utils->TreeRoot,user,0);
 		user->WriteServ("365 %s * :End of /LINKS list.",user->nick);
 		return;
 	}
@@ -3922,14 +4190,33 @@ class ModuleSpanningTree : public Module
 		if (n_users > max_global)
 			max_global = n_users;
 
-		user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-ServerInstance->InvisibleUserCount(),ServerInstance->InvisibleUserCount(),this->CountServs());
+		unsigned int ulined_count = 0;
+		unsigned int ulined_local_count = 0;
+
+		/* If ulined are hidden and we're not an oper, count the number of ulined servers hidden,
+		 * locally and globally (locally means directly connected to us)
+		 */
+		if ((Utils->HideULines) && (!*user->oper))
+		{
+			for (server_hash::iterator q = Utils->serverlist.begin(); q != Utils->serverlist.end(); q++)
+			{
+				if (ServerInstance->ULine(q->second->GetName().c_str()))
+				{
+					ulined_count++;
+					if (q->second->GetParent() == Utils->TreeRoot)
+						ulined_local_count++;
+				}
+			}
+		}
+
+		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(),this->CountLocalServs());
+		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("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;
@@ -3976,16 +4263,16 @@ class ModuleSpanningTree : public Module
 			line++;
 			for (unsigned int q = 0; q < Current->ChildCount(); q++)
 			{
-				if ((HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
+				if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
 				{
 					if (*user->oper)
 					{
-						ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
+						ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
 					}
 				}
 				else
 				{
-					ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
+					ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
 				}
 			}
 		}
@@ -4000,10 +4287,10 @@ class ModuleSpanningTree : public Module
 			params.push_back(parameters[0]);
 
 			/* Send it out remotely, generate no reply yet */
-			TreeServer* s = FindServerMask(parameters[0]);
+			TreeServer* s = Utils->FindServerMask(parameters[0]);
 			if (s)
 			{
-				DoOneToOne(user->nick, "MOTD", params, s->GetName());
+				Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName());
 			}
 			else
 			{
@@ -4023,10 +4310,10 @@ class ModuleSpanningTree : public Module
 			params.push_back(parameters[0]);
 
 			/* Send it out remotely, generate no reply yet */
-			TreeServer* s = FindServerMask(parameters[0]);
+			TreeServer* s = Utils->FindServerMask(parameters[0]);
 			if (s)
 			{
-				DoOneToOne(user->nick, "ADMIN", params, s->GetName());
+				Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName());
 			}
 			else
 			{
@@ -4046,11 +4333,11 @@ class ModuleSpanningTree : public Module
 			params.push_back(parameters[0]);
 			params.push_back(parameters[1]);
 			/* Send it out remotely, generate no reply yet */
-			TreeServer* s = FindServerMask(parameters[1]);
+			TreeServer* s = Utils->FindServerMask(parameters[1]);
 			if (s)
 			{
 				params[1] = s->GetName();
-				DoOneToOne(user->nick, "STATS", params, s->GetName());
+				Utils->DoOneToOne(user->nick, "STATS", params, s->GetName());
 			}
 			else
 			{
@@ -4084,7 +4371,7 @@ class ModuleSpanningTree : public Module
 		}
 		line = 0;
 		// The only recursive bit is called here.
-		ShowMap(TreeRoot,user,0,matrix,totusers,totservers);
+		ShowMap(Utils->TreeRoot,user,0,matrix,totusers,totservers);
 		// Process each line one by one. The algorithm has a limit of
 		// 128 servers (which is far more than a spanning tree should have
 		// anyway, so we're ok). This limit can be raised simply by making
@@ -4128,10 +4415,10 @@ class ModuleSpanningTree : public Module
 
 	int HandleSquit(const char** parameters, int pcnt, userrec* user)
 	{
-		TreeServer* s = FindServerMask(parameters[0]);
+		TreeServer* s = Utils->FindServerMask(parameters[0]);
 		if (s)
 		{
-			if (s == TreeRoot)
+			if (s == Utils->TreeRoot)
 			{
 				 user->WriteServ("NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]);
 				return 1;
@@ -4162,17 +4449,17 @@ class ModuleSpanningTree : public Module
 	{
 		if ((IS_LOCAL(user)) && (pcnt))
 		{
-			TreeServer* found = FindServerMask(parameters[0]);
+			TreeServer* found = Utils->FindServerMask(parameters[0]);
 			if (found)
 			{
 				// we dont' override for local server
-				if (found == TreeRoot)
+				if (found == Utils->TreeRoot)
 					return 0;
 				
 				std::deque<std::string> params;
 				params.push_back(found->GetName());
 				params.push_back(user->nick);
-				DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName());
+				Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName());
 			}
 			else
 			{
@@ -4191,7 +4478,7 @@ class ModuleSpanningTree : public Module
 			{
 				std::deque<std::string> params;
 				params.push_back(parameters[1]);
-				DoOneToOne(user->nick,"IDLE",params,remote->server);
+				Utils->DoOneToOne(user->nick,"IDLE",params,remote->server);
 				return 1;
 			}
 			else if (!remote)
@@ -4206,9 +4493,9 @@ class ModuleSpanningTree : public Module
 
 	void DoPingChecks(time_t curtime)
 	{
-		for (unsigned int j = 0; j < TreeRoot->ChildCount(); j++)
+		for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++)
 		{
-			TreeServer* serv = TreeRoot->GetChild(j);
+			TreeServer* serv = Utils->TreeRoot->GetChild(j);
 			TreeSocket* sock = serv->GetSocket();
 			if (sock)
 			{
@@ -4241,7 +4528,7 @@ class ModuleSpanningTree : public Module
 		/* Do we already have an IP? If so, no need to resolve it. */
 		if (insp_aton(x->IPAddr.c_str(), &binip) > 0)
 		{
-			TreeSocket* newsocket = new TreeSocket(ServerInstance, x->IPAddr,x->Port,false,10,x->Name.c_str());
+			TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port,false,x->Timeout ? x->Timeout : 10,x->Name.c_str());
 			if (newsocket->GetFd() > -1)
 			{
 				/* Handled automatically on success */
@@ -4250,70 +4537,36 @@ class ModuleSpanningTree : public Module
 			{
 				ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
 				delete newsocket;
-				this->DoFailOver(x);
+				Utils->DoFailOver(x);
 			}
 		}
 		else
 		{
 			try
 			{
-				ServernameResolver* snr = new ServernameResolver(ServerInstance,x->IPAddr, *x);
+				ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x);
 				ServerInstance->AddResolver(snr);
 			}
 			catch (ModuleException& e)
 			{
 				ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
-				this->DoFailOver(x);
-			}
-		}
-	}
-
-	void DoFailOver(Link* x)
-	{
-		if (x->FailOver.length())
-		{
-			if (x->FailOver == x->Name)
-			{
-				ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Some muppet configured the failover for server \002%s\002 to point at itself. Not following it!", x->Name.c_str());
-				return;
-			}
-			Link* TryThisOne = this->FindLink(x->FailOver.c_str());
-			if (TryThisOne)
-			{
-				ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Trying failover link for \002%s\002: \002%s\002...", x->Name.c_str(), TryThisOne->Name.c_str());
-				ConnectServer(TryThisOne);
-			}
-			else
-			{
-				ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Invalid failover server specified for server \002%s\002, will not follow!", x->Name.c_str());
+				Utils->DoFailOver(x);
 			}
 		}
 	}
 
-	Link* FindLink(const std::string& name)
-	{
-		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
-		{
-			if (ServerInstance->MatchText(x->Name.c_str(), name.c_str()))
-			{
-				return &(*x);
-			}
-		}
-		return NULL;
-	}
-
 	void AutoConnectServers(time_t curtime)
 	{
-		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+		for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 		{
 			if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
 			{
 				ServerInstance->Log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
 				x->NextConnectTime = curtime + x->AutoConnect;
-				TreeServer* CheckDupe = FindServer(x->Name.c_str());
+				TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
 				if (x->FailOver.length())
 				{
-					TreeServer* CheckFailOver = FindServer(x->FailOver.c_str());
+					TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str());
 					if (CheckFailOver)
 					{
 						/* The failover for this server is currently a member of the network.
@@ -4336,12 +4589,12 @@ class ModuleSpanningTree : public Module
 	int HandleVersion(const char** parameters, int pcnt, userrec* user)
 	{
 		// we've already checked if pcnt > 0, so this is safe
-		TreeServer* found = FindServerMask(parameters[0]);
+		TreeServer* found = Utils->FindServerMask(parameters[0]);
 		if (found)
 		{
 			std::string Version = found->GetVersion();
 			user->WriteServ("351 %s :%s",user->nick,Version.c_str());
-			if (found == TreeRoot)
+			if (found == Utils->TreeRoot)
 			{
 				std::stringstream out(ServerInstance->Config->data005);
 				std::string token = "";
@@ -4372,11 +4625,11 @@ class ModuleSpanningTree : public Module
 	
 	int HandleConnect(const char** parameters, int pcnt, userrec* user)
 	{
-		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+		for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 		{
 			if (ServerInstance->MatchText(x->Name.c_str(),parameters[0]))
 			{
-				TreeServer* CheckDupe = FindServer(x->Name.c_str());
+				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);
@@ -4394,14 +4647,22 @@ class ModuleSpanningTree : public Module
 		return 1;
 	}
 
+	void BroadcastTimeSync()
+	{
+		std::deque<std::string> params;
+		params.push_back(ConvToStr(ServerInstance->Time(true)));
+		Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
+	}
+
 	virtual int OnStats(char statschar, userrec* user, string_list &results)
 	{
-		if (statschar == 'c')
+		if ((statschar == 'c') || (statschar == 'n'))
 		{
-			for (unsigned int i = 0; i < LinkBlocks.size(); i++)
+			for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++)
 			{
-				results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" C *@"+(LinkBlocks[i].HiddenFromStats ? "<hidden>" : LinkBlocks[i].IPAddr)+" * "+LinkBlocks[i].Name.c_str()+" "+ConvToStr(LinkBlocks[i].Port)+" "+(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-')+(LinkBlocks[i].AutoConnect ? 'a' : '-')+'s');
-				results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+LinkBlocks[i].Name.c_str());
+				results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "<hidden>" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].EncryptionKey != "" ? 'e' : '-')+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s');
+				if (statschar == 'c')
+					results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str());
 			}
 			results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
 			ServerInstance->SNO->WriteToSnoMask('t',"Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
@@ -4495,13 +4756,13 @@ class ModuleSpanningTree : public Module
 				}
 			}
 			ServerInstance->Log(DEBUG,"Globally route '%s'",command.c_str());
-			DoOneToMany(user->nick,command,params);
+			Utils->DoOneToMany(user->nick,command,params);
 		}
 	}
 
 	virtual void OnGetServerDescription(const std::string &servername,std::string &description)
 	{
-		TreeServer* s = FindServer(servername);
+		TreeServer* s = Utils->FindServer(servername);
 		if (s)
 		{
 			description = s->GetDesc();
@@ -4515,7 +4776,7 @@ class ModuleSpanningTree : public Module
 			std::deque<std::string> params;
 			params.push_back(dest->nick);
 			params.push_back(channel->name);
-			DoOneToMany(source->nick,"INVITE",params);
+			Utils->DoOneToMany(source->nick,"INVITE",params);
 		}
 	}
 
@@ -4524,7 +4785,7 @@ class ModuleSpanningTree : public Module
 		std::deque<std::string> params;
 		params.push_back(chan->name);
 		params.push_back(":"+topic);
-		DoOneToMany(user->nick,"TOPIC",params);
+		Utils->DoOneToMany(user->nick,"TOPIC",params);
 	}
 
 	virtual void OnWallops(userrec* user, const std::string &text)
@@ -4533,11 +4794,11 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(":"+text);
-			DoOneToMany(user->nick,"WALLOPS",params);
+			Utils->DoOneToMany(user->nick,"WALLOPS",params);
 		}
 	}
 
-	virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status)
+	virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
 	{
 		if (target_type == TYPE_USER)
 		{
@@ -4548,7 +4809,7 @@ class ModuleSpanningTree : public Module
 				params.clear();
 				params.push_back(d->nick);
 				params.push_back(":"+text);
-				DoOneToOne(user->nick,"NOTICE",params,d->server);
+				Utils->DoOneToOne(user->nick,"NOTICE",params,d->server);
 			}
 		}
 		else if (target_type == TYPE_CHANNEL)
@@ -4561,12 +4822,12 @@ class ModuleSpanningTree : public Module
 					std::string cname = c->name;
 					if (status)
 						cname = status + cname;
-					std::deque<TreeServer*> list;
-					GetListOfServersForChannel(c,list);
-					unsigned int ucount = list.size();
-					for (unsigned int i = 0; i < ucount; i++)
+					TreeServerList list;
+					Utils->GetListOfServersForChannel(c,list,status,exempt_list);
+
+					for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
 					{
-						TreeSocket* Sock = list[i]->GetSocket();
+						TreeSocket* Sock = i->second->GetSocket();
 						if (Sock)
 							Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text);
 					}
@@ -4581,12 +4842,12 @@ class ModuleSpanningTree : public Module
 				std::deque<std::string> par;
 				par.push_back(target);
 				par.push_back(":"+text);
-				DoOneToMany(user->nick,"NOTICE",par);
+				Utils->DoOneToMany(user->nick,"NOTICE",par);
 			}
 		}
 	}
 
-	virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status)
+	virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
 	{
 		if (target_type == TYPE_USER)
 		{
@@ -4599,7 +4860,7 @@ class ModuleSpanningTree : public Module
 				params.clear();
 				params.push_back(d->nick);
 				params.push_back(":"+text);
-				DoOneToOne(user->nick,"PRIVMSG",params,d->server);
+				Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server);
 			}
 		}
 		else if (target_type == TYPE_CHANNEL)
@@ -4612,12 +4873,12 @@ class ModuleSpanningTree : public Module
 					std::string cname = c->name;
 					if (status)
 						cname = status + cname;
-					std::deque<TreeServer*> list;
-					GetListOfServersForChannel(c,list);
-					unsigned int ucount = list.size();
-					for (unsigned int i = 0; i < ucount; i++)
+					TreeServerList list;
+					Utils->GetListOfServersForChannel(c,list,status,exempt_list);
+
+					for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
 					{
-						TreeSocket* Sock = list[i]->GetSocket();
+						TreeSocket* Sock = i->second->GetSocket();
 						if (Sock)
 							Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text);
 					}
@@ -4632,7 +4893,7 @@ class ModuleSpanningTree : public Module
 				std::deque<std::string> par;
 				par.push_back(target);
 				par.push_back(":"+text);
-				DoOneToMany(user->nick,"PRIVMSG",par);
+				Utils->DoOneToMany(user->nick,"PRIVMSG",par);
 			}
 		}
 	}
@@ -4658,7 +4919,15 @@ class ModuleSpanningTree : public Module
 			params.push_back(channel->name);
 			params.push_back(ConvToStr(channel->age));
 			params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->nick));
-			DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
+			if (channel->GetUserCounter() == 1)
+			{
+				/* 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);
+			}
 		}
 	}
 
@@ -4669,7 +4938,7 @@ class ModuleSpanningTree : public Module
 			return;
 		std::deque<std::string> params;
 		params.push_back(newhost);
-		DoOneToMany(user->nick,"FHOST",params);
+		Utils->DoOneToMany(user->nick,"FHOST",params);
 	}
 
 	virtual void OnChangeName(userrec* user, const std::string &gecos)
@@ -4679,7 +4948,7 @@ class ModuleSpanningTree : public Module
 			return;
 		std::deque<std::string> params;
 		params.push_back(gecos);
-		DoOneToMany(user->nick,"FNAME",params);
+		Utils->DoOneToMany(user->nick,"FNAME",params);
 	}
 
 	virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage)
@@ -4690,7 +4959,7 @@ class ModuleSpanningTree : public Module
 			params.push_back(channel->name);
 			if (partmessage != "")
 				params.push_back(":"+partmessage);
-			DoOneToMany(user->nick,"PART",params);
+			Utils->DoOneToMany(user->nick,"PART",params);
 		}
 	}
 
@@ -4709,10 +4978,10 @@ class ModuleSpanningTree : public Module
 			params.push_back("+"+std::string(user->FormatModes()));
 			params.push_back(user->GetIPString());
 			params.push_back(":"+std::string(user->fullname));
-			DoOneToMany(ServerInstance->Config->ServerName,"NICK",params);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params);
 
 			// User is Local, change needs to be reflected!
-			TreeServer* SourceServer = FindServer(user->server);
+			TreeServer* SourceServer = Utils->FindServer(user->server);
 			if (SourceServer)
 			{
 				SourceServer->AddUserCount();
@@ -4727,10 +4996,10 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(":"+reason);
-			DoOneToMany(user->nick,"QUIT",params);
+			Utils->DoOneToMany(user->nick,"QUIT",params);
 		}
 		// Regardless, We need to modify the user Counts..
-		TreeServer* SourceServer = FindServer(user->server);
+		TreeServer* SourceServer = Utils->FindServer(user->server);
 		if (SourceServer)
 		{
 			SourceServer->DelUserCount();
@@ -4744,7 +5013,7 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(user->nick);
-			DoOneToMany(oldnick,"NICK",params);
+			Utils->DoOneToMany(oldnick,"NICK",params);
 		}
 	}
 
@@ -4756,7 +5025,7 @@ class ModuleSpanningTree : public Module
 			params.push_back(chan->name);
 			params.push_back(user->nick);
 			params.push_back(":"+reason);
-			DoOneToMany(source->nick,"KICK",params);
+			Utils->DoOneToMany(source->nick,"KICK",params);
 		}
 		else if (!source)
 		{
@@ -4764,7 +5033,7 @@ class ModuleSpanningTree : public Module
 			params.push_back(chan->name);
 			params.push_back(user->nick);
 			params.push_back(":"+reason);
-			DoOneToMany(ServerInstance->Config->ServerName,"KICK",params);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params);
 		}
 	}
 
@@ -4773,7 +5042,7 @@ class ModuleSpanningTree : public Module
 		std::deque<std::string> params;
 		params.push_back(dest->nick);
 		params.push_back(":"+reason);
-		DoOneToMany(source->nick,"KILL",params);
+		Utils->DoOneToMany(source->nick,"KILL",params);
 	}
 
 	virtual void OnRehash(const std::string &parameter)
@@ -4782,7 +5051,7 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(parameter);
-			DoOneToMany(ServerInstance->Config->ServerName,"REHASH",params);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"REHASH",params);
 			// check for self
 			if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter))
 			{
@@ -4790,7 +5059,7 @@ class ModuleSpanningTree : public Module
 				ServerInstance->RehashServer();
 			}
 		}
-		ReadConfiguration(false);
+		Utils->ReadConfiguration(false);
 	}
 
 	// note: the protocol does not allow direct umode +o except
@@ -4802,32 +5071,45 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(opertype);
-			DoOneToMany(user->nick,"OPERTYPE",params);
+			Utils->DoOneToMany(user->nick,"OPERTYPE",params);
 		}
 	}
 
 	void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason)
 	{
-		if (IS_LOCAL(source))
+		if (!source)
 		{
-			char type[8];
-			snprintf(type,8,"%cLINE",linetype);
-			std::string stype = type;
-			if (adding)
-			{
-				char sduration[MAXBUF];
-				snprintf(sduration,MAXBUF,"%ld",duration);
-				std::deque<std::string> params;
-				params.push_back(host);
-				params.push_back(sduration);
-				params.push_back(":"+reason);
-				DoOneToMany(source->nick,stype,params);
-			}
-			else
+			/* Server-set lines */
+			char data[MAXBUF];
+			snprintf(data,MAXBUF,"%c %s %s %lu %lu :%s", linetype, host.c_str(), ServerInstance->Config->ServerName, (unsigned long)ServerInstance->Time(false),
+					(unsigned long)duration, reason.c_str());
+			std::deque<std::string> params;
+			params.push_back(data);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params);
+		}
+		else
+		{
+			if (IS_LOCAL(source))
 			{
-				std::deque<std::string> params;
-				params.push_back(host);
-				DoOneToMany(source->nick,stype,params);
+				char type[8];
+				snprintf(type,8,"%cLINE",linetype);
+				std::string stype = type;
+				if (adding)
+				{
+					char sduration[MAXBUF];
+					snprintf(sduration,MAXBUF,"%ld",duration);
+					std::deque<std::string> params;
+					params.push_back(host);
+					params.push_back(sduration);
+					params.push_back(":"+reason);
+					Utils->DoOneToMany(source->nick,stype,params);
+				}
+				else
+				{
+					std::deque<std::string> params;
+					params.push_back(host);
+					Utils->DoOneToMany(source->nick,stype,params);
+				}
 			}
 		}
 	}
@@ -4882,7 +5164,7 @@ class ModuleSpanningTree : public Module
 				std::deque<std::string> params;
 				params.push_back(u->nick);
 				params.push_back(text);
-				DoOneToMany(user->nick,"MODE",params);
+				Utils->DoOneToMany(user->nick,"MODE",params);
 			}
 			else
 			{
@@ -4890,7 +5172,7 @@ class ModuleSpanningTree : public Module
 				std::deque<std::string> params;
 				params.push_back(c->name);
 				params.push_back(text);
-				DoOneToMany(user->nick,"MODE",params);
+				Utils->DoOneToMany(user->nick,"MODE",params);
 			}
 		}
 	}
@@ -4901,7 +5183,7 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.push_back(":"+std::string(user->awaymsg));
-			DoOneToMany(user->nick,"AWAY",params);
+			Utils->DoOneToMany(user->nick,"AWAY",params);
 		}
 	}
 
@@ -4911,7 +5193,7 @@ class ModuleSpanningTree : public Module
 		{
 			std::deque<std::string> params;
 			params.clear();
-			DoOneToMany(user->nick,"AWAY",params);
+			Utils->DoOneToMany(user->nick,"AWAY",params);
 		}
 	}
 
@@ -4964,7 +5246,7 @@ class ModuleSpanningTree : public Module
 			if (params->size() < 3)
 				return;
 			(*params)[2] = ":" + (*params)[2];
-			DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
 		}
 		else if (event->GetEventID() == "send_topic")
 		{
@@ -4972,8 +5254,8 @@ class ModuleSpanningTree : public Module
 				return;
 			(*params)[1] = ":" + (*params)[1];
 			params->insert(params->begin() + 1,ServerInstance->Config->ServerName);
-			params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time()));
-			DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
+			params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time(true)));
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
 		}
 		else if (event->GetEventID() == "send_mode")
 		{
@@ -4995,34 +5277,57 @@ class ModuleSpanningTree : public Module
 				}
 			}
 			params->insert(params->begin() + 1,ConvToStr(ourTS));
-			DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params);
+			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);
+		}
+		else if (event->GetEventID() == "send_opers")
+		{
+			if (params->size() < 1)
+				return;
+			(*params)[0] = ":" + (*params)[0];
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params);
+		}
+		else if (event->GetEventID() == "send_modeset")
+		{
+			if (params->size() < 2)
+				return;
+			(*params)[1] = ":" + (*params)[1];
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params);
+		}
+		else if (event->GetEventID() == "send_snoset")
+		{
+			if (params->size() < 2)
+				return;
+			(*params)[1] = ":" + (*params)[1];
+			Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params);
+		}
+		else if (event->GetEventID() == "send_push")
+		{
+			if (params->size() < 2)
+				return;
+			
+			userrec *a = ServerInstance->FindNick((*params)[0]);
+			
+			if (!a)
+				return;
+			
+			(*params)[1] = ":" + (*params)[1];
+			Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server);
 		}
 	}
 
 	virtual ~ModuleSpanningTree()
 	{
 		ServerInstance->Log(DEBUG,"Performing unload of spanningtree!");
-		ServerInstance->Log(DEBUG,"Freeing %d bindings...",Bindings.size());
-		for (unsigned int i = 0; i < Bindings.size(); i++)
-		{
-			ServerInstance->Log(DEBUG,"Freeing binding %d of %d",i, Bindings.size());
-			ServerInstance->SE->DelFd(Bindings[i]);
-			Bindings[i]->Close();
-			DELETE(Bindings[i]);
-		}
-		ServerInstance->Log(DEBUG,"Freeing connected servers...");
-		while (TreeRoot->ChildCount())
-		{
-			TreeServer* child_server = TreeRoot->GetChild(0);
-			ServerInstance->Log(DEBUG,"Freeing connected server %s", child_server->GetName().c_str());
-			if (child_server)
-			{
-				TreeSocket* sock = child_server->GetSocket();
-				ServerInstance->SE->DelFd(sock);
-				sock->Close();
-				DELETE(sock);
-			}
-		}	       
+		/* This will also free the listeners */
+		delete Utils;
+		if (SyncTimer)
+			ServerInstance->Timers->DelTimer(SyncTimer);
 	}
 
 	virtual Version GetVersion()
@@ -5054,14 +5359,49 @@ class ModuleSpanningTree : public Module
 	}
 };
 
-void DoFailOver(Link* x)
+TimeSyncTimer::TimeSyncTimer(InspIRCd *Inst, ModuleSpanningTree *Mod) : InspTimer(43200, Inst->Time()), Instance(Inst), Module(Mod)
+{
+}
+
+void TimeSyncTimer::Tick(time_t TIME)
 {
-	TreeProtocolModule->DoFailOver(x);
+	Module->BroadcastTimeSync();
+	Module->SyncTimer = new TimeSyncTimer(Instance, Module);
+	Instance->Timers->AddTimer(Module->SyncTimer);
+}
+
+void SpanningTreeUtilities::DoFailOver(Link* x)
+{
+	if (x->FailOver.length())
+	{
+		if (x->FailOver == x->Name)
+		{
+			ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Some muppet configured the failover for server \002%s\002 to point at itself. Not following it!", x->Name.c_str());
+			return;
+		}
+		Link* TryThisOne = this->FindLink(x->FailOver.c_str());
+		if (TryThisOne)
+		{
+			ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Trying failover link for \002%s\002: \002%s\002...", x->Name.c_str(), TryThisOne->Name.c_str());
+			Creator->ConnectServer(TryThisOne);
+		}
+		else
+		{
+			ServerInstance->SNO->WriteToSnoMask('l',"FAILOVER: Invalid failover server specified for server \002%s\002, will not follow!", x->Name.c_str());
+		}
+	}
 }
 
-Link* FindLink(const std::string& name)
+Link* SpanningTreeUtilities::FindLink(const std::string& name)
 {
-	return TreeProtocolModule->FindLink(name);
+	for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
+	{
+		if (ServerInstance->MatchText(x->Name.c_str(), name.c_str()))
+		{
+			return &(*x);
+		}
+	}
+	return NULL;
 }
 
 class ModuleSpanningTreeFactory : public ModuleFactory
@@ -5077,8 +5417,7 @@ class ModuleSpanningTreeFactory : public ModuleFactory
 	
 	virtual Module * CreateModule(InspIRCd* Me)
 	{
-		TreeProtocolModule = new ModuleSpanningTree(Me);
-		return TreeProtocolModule;
+		return new ModuleSpanningTree(Me);
 	}
 	
 };