X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree.cpp;h=0725d7b51767dab0ea2d9c40a8b27b7418242b6c;hb=4488e477136ea3daa60a744bac272cc37a604136;hp=3f3613dd29ac24d61144e3c607ba61f353d2e307;hpb=981ca37d6641404548a13623b90438f8f1c87ded;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/modules/m_spanningtree.cpp b/src/modules/m_spanningtree.cpp
index 3f3613dd2..0725d7b51 100644
--- a/src/modules/m_spanningtree.cpp
+++ b/src/modules/m_spanningtree.cpp
@@ -23,15 +23,14 @@ using namespace std;
 #include <deque>
 #include "globals.h"
 #include "inspircd_config.h"
-#ifdef GCC3
-#include <ext/hash_map>
-#else
-#include <hash_map>
-#endif
+#include "hash_map.h"
+#include "configreader.h"
 #include "users.h"
 #include "channels.h"
 #include "modules.h"
 #include "commands.h"
+#include "commands/cmd_whois.h"
+#include "commands/cmd_stats.h"
 #include "socket.h"
 #include "helperfuncs.h"
 #include "inspircd.h"
@@ -43,11 +42,7 @@ using namespace std;
 #include "cull_list.h"
 #include "aes.h"
 
-#ifdef GCC3
 #define nspace __gnu_cxx
-#else
-#define nspace std
-#endif
 
 /*
  * The server list in InspIRCd is maintained as two structures
@@ -114,9 +109,12 @@ static Server* Srv;
 /* This hash_map holds the hash equivalent of the server
  * tree, used for rapid linear lookups.
  */
-typedef nspace::hash_map<std::string, TreeServer*> server_hash;
+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);
@@ -141,6 +139,53 @@ extern std::vector<ZLine> pzlines;
 extern std::vector<QLine> pqlines;
 extern std::vector<ELine> pelines;
 
+class UserManager : 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 "";
+	}
+
+	std::string SIDToServer(const std::string &SID)
+	{
+		return "";
+	}
+
+	userrec* FindByID(const std::string &UID)
+	{
+		return NULL;
+	}
+};
+
 /* Each server in the tree is represented by one class of
  * type TreeServer. A locally connected TreeServer can
  * have a class of type TreeSocket associated with it, for
@@ -151,17 +196,17 @@ extern std::vector<ELine> pelines;
  * constructors below), and also a dynamic list of pointers
  * to its children which can be iterated recursively
  * if required. Creating or deleting objects of type
- * TreeServer automatically maintains the hash_map of
+ i* TreeServer automatically maintains the hash_map of
  * TreeServer items, deleting and inserting them as they
  * are created and destroyed.
  */
 
-class TreeServer
+class TreeServer : public classbase
 {
 	TreeServer* Parent;			/* Parent entry */
 	TreeServer* Route;			/* Route entry */
 	std::vector<TreeServer*> Children;	/* List of child objects */
-	std::string ServerName;			/* Server's name */
+	irc::string ServerName;			/* Server's name */
 	std::string ServerDesc;			/* Server's description */
 	std::string VersionString;		/* Version string or empty string */
 	int UserCount;				/* Not used in this version */
@@ -169,7 +214,6 @@ class TreeServer
 	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 */
-	std::map<userrec*,userrec*> Users;	/* Users on this server */
 	
  public:
 
@@ -190,7 +234,7 @@ class TreeServer
 	 * 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(std::string Name, std::string Desc) : ServerName(Name), ServerDesc(Desc)
+	TreeServer(std::string Name, std::string Desc) : ServerName(Name.c_str()), ServerDesc(Desc)
 	{
 		Parent = NULL;
 		VersionString = "";
@@ -205,7 +249,7 @@ class TreeServer
 	 * 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(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock)
+	TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name.c_str()), ServerDesc(Desc), Socket(Sock)
 	{
 		VersionString = "";
 		UserCount = OperCount = 0;
@@ -266,36 +310,26 @@ class TreeServer
 		this->AddHashEntry();
 	}
 
-	void AddUser(userrec* user)
-	{
-		log(DEBUG,"Add user %s to server %s",user->nick,this->ServerName.c_str());
-		std::map<userrec*,userrec*>::iterator iter;
-		iter = Users.find(user);
-		if (iter == Users.end())
-			Users[user] = user;
-	}
-
-	void DelUser(userrec* user)
-	{
-		log(DEBUG,"Remove user %s from server %s",user->nick,this->ServerName.c_str());
-		std::map<userrec*,userrec*>::iterator iter;
-		iter = Users.find(user);
-		if (iter != Users.end())
-			Users.erase(iter);
-	}
-
 	int QuitUsers(const std::string &reason)
 	{
-		int x = Users.size();
 		log(DEBUG,"Removing all users from server %s",this->ServerName.c_str());
 		const char* reason_s = reason.c_str();
-		for (std::map<userrec*,userrec*>::iterator n = Users.begin(); n != Users.end(); n++)
+		std::vector<userrec*> time_to_die;
+		for (user_hash::iterator n = clientlist.begin(); n != clientlist.end(); n++)
 		{
-			log(DEBUG,"Kill %s",n->second->nick);
-			kill_link(n->second,reason_s);
+			if (!strcmp(n->second->server, this->ServerName.c_str()))
+			{
+				time_to_die.push_back(n->second);
+			}
+		}
+		for (std::vector<userrec*>::iterator n = time_to_die.begin(); n != time_to_die.end(); n++)
+		{
+			userrec* a = (userrec*)*n;
+			log(DEBUG,"Kill %s fd=%d",a->nick,a->fd);
+			if (!IS_LOCAL(a))
+				kill_link(a,reason_s);
 		}
-		Users.clear();
-		return x;
+		return time_to_die.size();
 	}
 
 	/* This method is used to add the structure to the
@@ -305,9 +339,9 @@ class TreeServer
 	void AddHashEntry()
 	{
 		server_hash::iterator iter;
-		iter = serverlist.find(this->ServerName);
+		iter = serverlist.find(this->ServerName.c_str());
 		if (iter == serverlist.end())
-			serverlist[this->ServerName] = this;
+			serverlist[this->ServerName.c_str()] = this;
 	}
 
 	/* This method removes the reference to this object
@@ -317,7 +351,7 @@ class TreeServer
 	void DelHashEntry()
 	{
 		server_hash::iterator iter;
-		iter = serverlist.find(this->ServerName);
+		iter = serverlist.find(this->ServerName.c_str());
 		if (iter != serverlist.end())
 			serverlist.erase(iter);
 	}
@@ -333,7 +367,7 @@ class TreeServer
 
 	std::string GetName()
 	{
-		return ServerName;
+		return ServerName.c_str();
 	}
 
 	std::string GetDesc()
@@ -457,7 +491,7 @@ class TreeServer
 				TreeServer* s = (TreeServer*)*a;
 				s->Tidy();
 				Children.erase(a);
-				delete s;
+				DELETE(s);
 				stillchildren = true;
 				break;
 			}
@@ -479,10 +513,10 @@ class TreeServer
  * of them, and populate the list on rehash/load.
  */
 
-class Link
+class Link : public classbase
 {
  public:
-	 std::string Name;
+	 irc::string Name;
 	 std::string IPAddr;
 	 int Port;
 	 std::string SendPass;
@@ -510,7 +544,7 @@ std::vector<Link> LinkBlocks;
 TreeServer* FindServer(std::string ServerName)
 {
 	server_hash::iterator iter;
-	iter = serverlist.find(ServerName);
+	iter = serverlist.find(ServerName.c_str());
 	if (iter != serverlist.end())
 	{
 		return iter->second;
@@ -552,7 +586,7 @@ TreeServer* FindServerMask(std::string ServerName)
 {
 	for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
 	{
-		if (Srv->MatchText(i->first,ServerName))
+		if (Srv->MatchText(i->first.c_str(),ServerName))
 			return i->second;
 	}
 	return NULL;
@@ -572,9 +606,10 @@ class cmd_rconnect : public command_t
 	cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback)
 	{
 		this->source = "m_spanningtree.so";
-	}                
+		syntax = "<remote-server-mask> <servermask>";
+	}
 
-	void Handle (char **parameters, int pcnt, userrec *user)
+	void Handle (const char** parameters, int pcnt, userrec *user)
 	{
 		WriteServ(user->fd,"NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]);
 		/* Is this aimed at our server? */
@@ -582,7 +617,7 @@ class cmd_rconnect : public command_t
 		{
 			/* Yes, initiate the given connect */
 			WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]);
-			char* para[1];
+			const char* para[1];
 			para[0] = parameters[1];
 			Creator->OnPreCommand("CONNECT", para, 1, user, true);
 		}
@@ -660,9 +695,9 @@ class TreeSocket : public InspSocket
 	~TreeSocket()
 	{
 		if (ctx_in)
-			delete ctx_in;
+			DELETE(ctx_in);
 		if (ctx_out)
-			delete ctx_out;
+			DELETE(ctx_out);
 	}
 
 	void InitAES(std::string key,std::string SName)
@@ -716,7 +751,7 @@ class TreeSocket : public InspSocket
 						else
 						{
 							this->WriteLine("AES "+Srv->GetServerName());
-							this->InitAES(x->EncryptionKey,x->Name);
+							this->InitAES(x->EncryptionKey,x->Name.c_str());
 						}
 					}
 					/* found who we're supposed to be connecting to, send the neccessary gubbins. */
@@ -740,6 +775,10 @@ class TreeSocket : public InspSocket
 		 * dirty work is done in OnClose() (see below)
 		 * which is still called on error conditions too.
 		 */
+		if (e == I_ERR_CONNECT)
+		{
+			Srv->SendOpers("*** Connection failed: Connection refused");
+		}
 	}
 
 	virtual int OnDisconnect()
@@ -849,14 +888,6 @@ class TreeSocket : public InspSocket
 		/* Now we've whacked the kids, whack self */
 		num_lost_servers++;
 		num_lost_users += Current->QuitUsers(from);
-		/*for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
-		{
-			if (!strcasecmp(u->second->server,Current->GetName().c_str()))
-			{
-				Goners->AddItem(u->second,from);
-				num_lost_users++;
-			}
-		}*/
 	}
 
 	/* This is a wrapper function for SquitServer above, which
@@ -885,7 +916,7 @@ class TreeSocket : public InspSocket
 			SquitServer(from, Current);
 			Current->Tidy();
 			Current->GetParent()->DelChild(Current);
-			delete Current;
+			DELETE(Current);
 			WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
 		}
 		else
@@ -894,22 +925,378 @@ class TreeSocket : public InspSocket
 		}
 	}
 
-	/* FMODE command */
+	/* FMODE command - server mode with timestamp checks */
 	bool ForceMode(std::string source, std::deque<std::string> &params)
 	{
-		if (params.size() < 2)
-			return true;
-		userrec* who = new userrec();
-		who->fd = FD_MAGIC_NUMBER;
-		char* modelist[64];
+		/* Chances are this is a 1.0 FMODE without TS */
+		if (params.size() < 3)
+		{
+			this->WriteLine("ERROR :Version 1.0 FMODE sent to version 1.1 server");
+			return false;
+		}
+		
+		bool smode = false;
+		std::string sourceserv;
+
+		/* Are we dealing with an FMODE from a user, or from a server? */
+		userrec* who = Srv->FindNick(source);
+		if (who)
+		{
+			/* FMODE from a user, set sourceserv to the users server name */
+			sourceserv = who->server;
+		}
+		else
+		{
+			/* FMODE from a server, create a fake user to receive mode feedback */
+			who = new userrec();
+			who->fd = FD_MAGIC_NUMBER;
+			smode = true;		/* Setting this flag tells us we should free the userrec later */
+			sourceserv = source;	/* Set sourceserv to the actual source string */
+		}
+		const char* modelist[64];
+		time_t TS = 0;
+		int n = 0;
 		memset(&modelist,0,sizeof(modelist));
-		for (unsigned int q = 0; q < params.size(); q++)
+		for (unsigned int q = 0; (q < params.size()) && (q < 64); q++)
+		{
+			if (q == 1)
+			{
+				/* The timestamp is in this position.
+				 * We don't want to pass that up to the
+				 * server->client protocol!
+				 */
+				TS = atoi(params[q].c_str());
+			}
+			else
+			{
+				/* Everything else is fine to append to the modelist */
+				modelist[n++] = params[q].c_str();
+			}
+				
+		}
+                /* Extract the TS value of the object, either userrec or chanrec */
+		userrec* dst = Srv->FindNick(params[0]);
+		chanrec* chan = NULL;
+		time_t ourTS = 0;
+		if (dst)
+		{
+			ourTS = dst->age;
+		}
+		else
+		{
+			chan = Srv->FindChannel(params[0]);
+			if (chan)
+			{
+				ourTS = chan->age;
+			}
+		}
+
+		/* TS is equal: Merge the mode changes, use voooodoooooo on modes
+		 * with parameters.
+		 */
+		if (TS == ourTS)
+		{
+			log(DEBUG,"Entering TS equality check");
+			ModeHandler* mh = NULL;
+			unsigned long paramptr = 3;
+			std::string to_bounce = "";
+			std::string to_keep = "";
+			std::vector<std::string> params_to_keep;
+			std::string params_to_bounce = "";
+			bool adding = true;
+			char cur_change = 1;
+			char old_change = 0;
+			char old_bounce_change = 0;
+			/* Merge modes, basically do special stuff to mode with params */
+			for (std::string::iterator x = params[2].begin(); x != params[2].end(); x++)
+			{
+				switch (*x)
+				{
+					case '-':
+						adding = false;
+					break;
+					case '+':
+						adding = true;
+					break;
+					default:
+						if (adding)
+						{
+							/* We only care about whats being set,
+							 * not whats being unset
+							 */
+							mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER);
+
+							if ((mh->GetNumParams(adding) > 0) && (!mh->IsListMode()))
+							{
+								/* We only want to do special things to
+								 * modes with parameters, we are going to rewrite
+								 * those parameters
+								 */
+								ModePair ret;
+								adding ? cur_change = '+' : cur_change = '-';
+
+								ret = mh->ModeSet(smode ? NULL : who, dst, chan, params[paramptr]);
+
+								/* The mode is set here, check which we should keep */
+								if (ret.first)
+								{
+									bool which_to_keep = mh->CheckTimeStamp(TS, ourTS, params[paramptr], ret.second, chan);
+
+									if (which_to_keep == true)
+									{
+										/* Keep ours, bounce theirs:
+										 * Send back ours to them and
+										 * drop their mode changs
+										 */
+										adding ? cur_change = '+' : cur_change = '-';
+										if (cur_change != old_bounce_change)
+											to_bounce += cur_change;
+										to_bounce += *x;
+										old_bounce_change = cur_change;
+
+										if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
+											params_to_bounce.append(" ").append(ret.second);
+									}
+									else
+									{
+										/* Keep theirs: Accept their mode change,
+										 * do nothing else
+										 */
+										adding ? cur_change = '+' : cur_change = '-';
+										if (cur_change != old_change)
+											to_keep += cur_change;
+										to_keep += *x;
+										old_change = cur_change;
+
+										if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
+											params_to_keep.push_back(params[paramptr]);
+									}
+								}
+								else
+								{
+									/* Mode isnt set here, we want it */
+									adding ? cur_change = '+' : cur_change = '-';
+									if (cur_change != old_change)
+										to_keep += cur_change;
+									to_keep += *x;
+									old_change = cur_change;
+
+									if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
+										params_to_keep.push_back(params[paramptr]);
+								}
+
+								paramptr++;
+							}
+							else
+							{
+								mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER);
+
+								if (mh)
+								{
+									adding ? cur_change = '+' : cur_change = '-';
+	
+									/* Just keep this, safe to merge with no checks
+									 * it has no parameters
+									 */
+	
+									if (cur_change != old_change)
+										to_keep += cur_change;
+									to_keep += *x;
+									old_change = cur_change;
+	
+									if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
+									{
+										log(DEBUG,"Mode removal %d %d",adding, mh->GetNumParams(adding));
+										params_to_keep.push_back(params[paramptr++]);
+									}
+								}
+							}
+						}
+						else
+						{
+							mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER);
+
+							if (mh)
+							{
+								/* Taking a mode away */
+								adding ? cur_change = '+' : cur_change = '-';
+
+								if (cur_change != old_change)
+									to_keep += cur_change;
+								to_keep += *x;
+								old_change = cur_change;
+
+								if ((mh->GetNumParams(adding) > 0) && (paramptr < params.size()))
+									params_to_keep.push_back(params[paramptr++]);
+							}
+						}
+					break;
+				}
+			}
+
+			if (to_bounce.length())
+			{
+				std::deque<std::string> newparams;
+				newparams.push_back(params[0]);
+				newparams.push_back(ConvToStr(ourTS));
+				newparams.push_back(to_bounce+params_to_bounce);
+				DoOneToOne(Srv->GetServerName(),"FMODE",newparams,sourceserv);
+			}
+
+			if (to_keep.length())
+			{
+				n = 0;
+				modelist[0] = params[0].c_str();
+				modelist[1] = to_keep.c_str();
+
+				for (unsigned int q = 2; (q < params.size()) && (q < 64); q++)
+						modelist[q] = params_to_keep[n++].c_str();
+
+                	        if (smode)
+				{
+					Srv->SendMode(modelist, n+2, who);
+				}
+				else
+				{
+					Srv->CallCommandHandler("MODE", modelist, n+2, who);
+				}
+
+				/* HOT POTATO! PASS IT ON! */
+				DoOneToAllButSender(source,"FMODE",params,sourceserv);
+			}
+		}
+		else
+		/* U-lined servers always win regardless of their TS */
+		if ((TS > ourTS) && (!Srv->IsUlined(source)))
+		{
+			/* Bounce the mode back to its sender.* We use our lower TS, so the other end
+			 * SHOULD accept it, if its clock is right.
+			 *
+			 * NOTE: We should check that we arent bouncing anything thats already set at this end.
+			 * If we are, bounce +ourmode to 'reinforce' it. This prevents desyncs.
+			 * e.g. They send +l 50, we have +l 10 set. rather than bounce -l 50, we bounce +l 10.
+			 *
+			 * Thanks to jilles for pointing out this one-hell-of-an-issue before i even finished
+			 * writing the code. It took me a while to come up with this solution.
+			 *
+			 * XXX: BE SURE YOU UNDERSTAND THIS CODE FULLY BEFORE YOU MESS WITH IT.
+			 */
+
+			std::deque<std::string> newparams;	/* New parameter list we send back */
+			newparams.push_back(params[0]);		/* Target, user or channel */
+			newparams.push_back(ConvToStr(ourTS));	/* Timestamp value of the target */
+			newparams.push_back("");		/* This contains the mode string. For now
+								 * it's empty, we fill it below.
+								 */
+
+			/* Intelligent mode bouncing. Don't just invert, reinforce any modes which are already
+			 * set to avoid a desync here.
+			 */
+			std::string modebounce = "";
+			bool adding = true;
+			unsigned int t = 3;
+			ModeHandler* mh = NULL;
+			char cur_change = 1;
+			char old_change = 0;
+			for (std::string::iterator x = params[2].begin(); x != params[2].end(); x++)
+			{
+				/* Iterate over all mode chars in the sent set */
+				switch (*x)
+				{
+					/* Adding or subtracting modes? */
+					case '-':
+						adding = false;
+					break;
+					case '+':
+						adding = true;
+					break;
+					default:
+						/* Find the mode handler for this mode */
+						mh = ServerInstance->ModeGrok->FindMode(*x, chan ? MODETYPE_CHANNEL : MODETYPE_USER);
+
+						/* Got a mode handler?
+						 * This also prevents us bouncing modes we have no handler for.
+						 */
+						if (mh)
+						{
+							ModePair ret;
+							std::string p = "";
+
+							/* Does the mode require a parameter right now?
+							 * If it does, fetch it if we can
+							 */
+							if ((mh->GetNumParams(adding) > 0) && (t < params.size()))
+								p = params[t++];
+
+							/* Call the ModeSet method to determine if its set with the
+							 * given parameter here or not.
+							 */
+							ret = mh->ModeSet(smode ? NULL : who, dst, chan, p);
+
+							/* XXX: Really. Dont ask.
+							 * Determine from if its set combined with what the current
+							 * 'state' is (adding or not) as to wether we should 'invert'
+							 * or 'reinforce' the mode change
+							 */
+							(!ret.first ? (adding ? cur_change = '-' : cur_change = '+') : (!adding ? cur_change = '-' : cur_change = '+'));
+
+							/* Quickly determine if we have 'flipped' from + to -,
+							 * or - to +, to prevent unneccessary +/- chars in the
+							 * output string that waste bandwidth
+							 */
+							if (cur_change != old_change)
+								modebounce += cur_change;
+							old_change = cur_change;
+
+							/* Add the mode character to the output string */
+							modebounce += mh->GetModeChar();
+
+							/* We got a parameter back from ModeHandler::ModeSet,
+							 * are we supposed to be sending one out right now?
+							 */
+							if (ret.second.length())
+							{
+								if (mh->GetNumParams(cur_change == '+') > 0)
+									/* Yes we're supposed to be sending out
+									 * the parameter. Make sure it goes
+									 */
+									newparams.push_back(ret.second);
+							}
+
+						}
+					break;
+				}
+			}
+			
+			/* 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(Srv->GetServerName(),"FMODE",newparams,sourceserv);
+			log(DEBUG,"FMODE bounced intelligently, our TS less than theirs and the other server is NOT a uline.");
+		}
+		else
 		{
-			modelist[q] = (char*)params[q].c_str();
+			log(DEBUG,"Allow modes, TS lower for sender");
+			/* The server was ulined, but something iffy is up with the TS.
+			 * Sound the alarm bells!
+			 */
+			if ((Srv->IsUlined(sourceserv)) && (TS > ourTS))
+			{
+				WriteOpers("\2WARNING!\2 U-Lined server '%s' has bad TS for '%s' (accepted change): \2SYNC YOUR CLOCKS\2 to avoid this notice",sourceserv.c_str(),params[0].c_str());
+			}
+			/* Allow the mode, route it to either server or user command handling */
+			if (smode)
+				Srv->SendMode(modelist,n,who);
+			else
+				Srv->CallCommandHandler("MODE", modelist, n, who);
+
+			/* HOT POTATO! PASS IT ON! */
+			DoOneToAllButSender(source,"FMODE",params,sourceserv);
 		}
-		Srv->SendMode(modelist,params.size(),who);
-		DoOneToAllButSender(source,"FMODE",params,source);
-		delete who;
+		/* Are we supposed to free the userrec? */
+		if (smode)
+			DELETE(who);
+
 		return true;
 	}
 
@@ -939,21 +1326,20 @@ class TreeSocket : public InspSocket
 					userrec* user = Srv->FindNick(source);
 					if (!user)
 					{
-						WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
+						WriteChannelWithServ(source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
 					}
 					else
 					{
 						WriteChannel(c, user, "TOPIC %s :%s", c->name, c->topic);
 						nsource = user->server;
 					}
+					/* all done, send it on its way */
+					params[3] = ":" + params[3];
+					DoOneToAllButSender(source,"FTOPIC",params,nsource);
 				}
 			}
 			
 		}
-		
-		/* all done, send it on its way */
-		params[3] = ":" + params[3];
-		DoOneToAllButSender(source,"FTOPIC",params,nsource);
 
 		return true;
 	}
@@ -970,7 +1356,7 @@ class TreeSocket : public InspSocket
 		memset(&mode_users,0,sizeof(mode_users));
 		mode_users[0] = first;
 		mode_users[1] = modestring;
-		strcpy(mode_users[1],"+");
+		strcpy(first,"+");
 		unsigned int modectr = 2;
 		
 		userrec* who = NULL;
@@ -1042,7 +1428,12 @@ class TreeSocket : public InspSocket
 						{
 							/* We also always let u-lined clients win, no matter what the TS value */
 							log(DEBUG,"Our our channel newer than theirs, accepting their modes");
-							Srv->SendMode(mode_users,modectr,who);
+							Srv->SendMode((const char**)mode_users,modectr,who);
+							if (ourTS != TS)
+							{
+								log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us,ourTS,TS);
+								us->age = TS;
+							}
 						}
 						else
 						{
@@ -1053,6 +1444,10 @@ class TreeSocket : public InspSocket
 							*mode_users[1] = '-';
 							for (unsigned int x = 0; x < modectr; x++)
 							{
+								if (x == 1)
+								{
+									params.push_back(ConvToStr(us->age));
+								}
 								params.push_back(mode_users[x]);
 							}
 							// tell everyone to bounce the modes. bad modes, bad!
@@ -1072,7 +1467,12 @@ class TreeSocket : public InspSocket
 			if (ourTS >= TS)
 			{
 				log(DEBUG,"Our our channel newer than theirs, accepting their modes");
-				Srv->SendMode(mode_users,modectr,who);
+				Srv->SendMode((const char**)mode_users,modectr,who);
+				if (ourTS != TS)
+				{
+					log(DEFAULT,"Channel TS for %s changed from %lu to %lu",us,ourTS,TS);
+					us->age = TS;
+				}
 			}
 			else
 			{
@@ -1081,6 +1481,10 @@ class TreeSocket : public InspSocket
 				*mode_users[1] = '-';
 				for (unsigned int x = 0; x < modectr; x++)
 				{
+					if (x == 1)
+					{
+						params.push_back(ConvToStr(us->age));
+					}
 					params.push_back(mode_users[x]);
 				}
 				DoOneToMany(Srv->GetServerName(),"FMODE",params);
@@ -1089,6 +1493,26 @@ class TreeSocket : public InspSocket
 		return true;
 	}
 
+	bool SyncChannelTS(std::string source, std::deque<std::string> &params)
+	{
+		if (params.size() >= 2)
+		{
+			chanrec* c = Srv->FindChannel(params[0]);
+			if (c)
+			{
+				time_t theirTS = atoi(params[1].c_str());
+				time_t ourTS = c->age;
+				if (ourTS >= theirTS)
+				{
+					log(DEBUG,"Updating timestamp for %s, our timestamp was %lu and theirs is %lu",c->name,ourTS,theirTS);
+					c->age = theirTS;
+				}
+			}
+		}
+		DoOneToAllButSender(Srv->GetServerName(),"SYNCTS",params,source);
+		return true;
+	}
+
 	/* NICK command */
 	bool IntroduceClient(std::string source, std::deque<std::string> &params)
 	{
@@ -1102,18 +1526,17 @@ class TreeSocket : public InspSocket
 		// NICK age nick host dhost ident +modes ip :gecos
 		//   0   123  4 56   7
 		time_t age = atoi(params[0].c_str());
-		std::string modes = params[5];
-		while (*(modes.c_str()) == '+')
-		{
-			char* m = (char*)modes.c_str();
-			m++;
-			modes = m;
-		}
-		char* tempnick = (char*)params[1].c_str();
+		
+		/* This used to have a pretty craq'y loop doing the same thing,
+		 * now we just let the STL do the hard work (more efficiently)
+		 */
+		params[5] = params[5].substr(params[5].find_first_not_of('+'));
+		
+		const char* tempnick = params[1].c_str();
 		log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str());
 		
-		user_hash::iterator iter;
-		iter = clientlist.find(tempnick);
+		user_hash::iterator iter = clientlist.find(tempnick);
+		
 		if (iter != clientlist.end())
 		{
 			// nick collision
@@ -1127,32 +1550,19 @@ class TreeSocket : public InspSocket
 		strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX-1);
 		strlcpy(clientlist[tempnick]->host, params[2].c_str(),63);
 		strlcpy(clientlist[tempnick]->dhost, params[3].c_str(),63);
-		clientlist[tempnick]->server = (char*)FindServerNamePtr(source.c_str());
+		clientlist[tempnick]->server = FindServerNamePtr(source.c_str());
 		strlcpy(clientlist[tempnick]->ident, params[4].c_str(),IDENTMAX);
 		strlcpy(clientlist[tempnick]->fullname, params[7].c_str(),MAXGECOS);
-		clientlist[tempnick]->registered = 7;
+		clientlist[tempnick]->registered = REG_ALL;
 		clientlist[tempnick]->signon = age;
-		strlcpy(clientlist[tempnick]->modes, modes.c_str(),53);
-		for (char *v = clientlist[tempnick]->modes; *v; v++)
+		
+		for (std::string::iterator v = params[5].begin(); v != params[5].end(); v++)
 		{
-			switch (*v)
-			{
-				case 'i':
-					clientlist[tempnick]->modebits |= UM_INVISIBLE;
-				break;
-				case 'w':
-					clientlist[tempnick]->modebits |= UM_WALLOPS;
-				break;
-				case 's':
-					clientlist[tempnick]->modebits |= UM_SERVERNOTICE;
-				break;
-				default:
-				break;
-			}
+			clientlist[tempnick]->modes[(*v)-65] = 1;
 		}
-		inet_aton(params[6].c_str(),&clientlist[tempnick]->ip4);
+		insp_aton(params[6].c_str(),&clientlist[tempnick]->ip4);
 
-		WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host,(char*)inet_ntoa(clientlist[tempnick]->ip4));
+		WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host, insp_ntoa(clientlist[tempnick]->ip4));
 
 		params[7] = ":" + params[7];
 		DoOneToAllButSender(source,"NICK",params,source);
@@ -1161,7 +1571,7 @@ class TreeSocket : public InspSocket
 		TreeServer* SourceServer = FindServer(source);
 		if (SourceServer)
 		{
-			SourceServer->AddUser(clientlist[tempnick]);
+			log(DEBUG,"Found source server of %s",clientlist[tempnick]->nick);
 			SourceServer->AddUserCount();
 		}
 
@@ -1176,7 +1586,7 @@ class TreeSocket : public InspSocket
 	{
 		log(DEBUG,"Sending FJOINs to other server for %s",c->name);
 		char list[MAXBUF];
-		std::string individual_halfops = ":"+Srv->GetServerName()+" FMODE "+c->name;
+		std::string individual_halfops = ":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age);
 		
 		size_t dlen, curlen;
 		dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
@@ -1186,6 +1596,8 @@ class TreeSocket : public InspSocket
 		CUList *ulist = c->GetUsers();
 		std::vector<userrec*> specific_halfop;
 		std::vector<userrec*> specific_voice;
+		std::string modes = "";
+		std::string params = "";
 
 		for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
 		{
@@ -1229,11 +1641,15 @@ class TreeSocket : public InspSocket
 				numusers = 0;
 				for (unsigned int y = 0; y < specific_voice.size(); y++)
 				{
-					this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +v "+specific_voice[y]->nick);
+					modes.append("v");
+					params.append(specific_voice[y]->nick).append(" ");
+					//this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +v "+specific_voice[y]->nick);
 				}
 				for (unsigned int y = 0; y < specific_halfop.size(); y++)
 				{
-					this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +h "+specific_halfop[y]->nick);
+					modes.append("h");
+					params.append(specific_halfop[y]->nick).append(" ");
+					//this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +h "+specific_halfop[y]->nick);
 				}
 			}
 		}
@@ -1242,13 +1658,27 @@ class TreeSocket : public InspSocket
 			this->WriteLine(list);
 			for (unsigned int y = 0; y < specific_voice.size(); y++)
 			{
-				this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +v "+specific_voice[y]->nick);
+				modes.append("v");
+				params.append(specific_voice[y]->nick).append(" ");
+				//this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +v "+specific_voice[y]->nick);
 			}
 			for (unsigned int y = 0; y < specific_halfop.size(); y++)
 			{
-				this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" +h "+specific_halfop[y]->nick);
+				modes.append("h");
+				params.append(specific_halfop[y]->nick).append(" ");
+				//this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +h "+specific_halfop[y]->nick);
 			}
 		}
+		//std::string modes = "";
+		//std::string params = "";
+                for (BanList::iterator b = c->bans.begin(); b != c->bans.end(); b++)
+                {
+			modes.append("b");
+			params.append(b->data).append(" ");
+                }
+		/* XXX: Send each channel mode and its params -- we'll need a method for this in ModeHandler? */
+                //FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
+		this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+chanmodes(c,true)+modes+" "+params);
 	}
 
 	/* Send G, Q, Z and E lines */
@@ -1263,73 +1693,41 @@ class TreeSocket : public InspSocket
 		{
 			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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<QLine>::iterator i = qlines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<GLine>::iterator i = glines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<ELine>::iterator i = elines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<ZLine>::iterator i = pzlines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<QLine>::iterator i = pqlines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<GLine>::iterator i = pglines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 		for (std::vector<ELine>::iterator i = pelines.begin(); i != 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);
-			if ((iterations % 10) == 0)
-			{
-				ServerInstance->DoOneIteration(false);
-			}
 		}
 	}
 
@@ -1344,18 +1742,11 @@ class TreeSocket : public InspSocket
 		for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++, iterations++)
 		{
 			SendFJoins(Current, c->second);
-			snprintf(data,MAXBUF,":%s FMODE %s +%s",sn,c->second->name,chanmodes(c->second,true));
-			this->WriteLine(data);
 			if (*c->second->topic)
 			{
 				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);
 			}
-			for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++)
-			{
-				snprintf(data,MAXBUF,":%s FMODE %s +b %s",sn,c->second->name,b->data);
-				this->WriteLine(data);
-			}
 			FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
 			list.clear();
 			c->second->GetExtList(list);
@@ -1374,9 +1765,9 @@ class TreeSocket : public InspSocket
 		int iterations = 0;
 		for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++, iterations++)
 		{
-			if (u->second->registered == 7)
+			if (u->second->registered == REG_ALL)
 			{
-				snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,(char*)inet_ntoa(u->second->ip4),u->second->fullname);
+				snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->FormatModes(),insp_ntoa(u->second->ip4),u->second->fullname);
 				this->WriteLine(data);
 				if (*u->second->oper)
 				{
@@ -1404,32 +1795,28 @@ class TreeSocket : public InspSocket
 	 */
 	void DoBurst(TreeServer* s)
 	{
-		/* The calls here to ServerInstance->DoOneIteration(false); yield the processing
+		/* The calls here to ServerInstance-> yield the processing
 		 * back to the core so that a large burst is split into at least 6 sections
 		 * (possibly more)
 		 */
 		std::string burst = "BURST "+ConvToStr(time(NULL));
 		std::string endburst = "ENDBURST";
-		Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
+		// Because by the end of the netburst, it  could be gone!
+		std::string name = s->GetName();
+		Srv->SendOpers("*** Bursting to \2"+name+"\2.");
 		this->WriteLine(burst);
-		ServerInstance->DoOneIteration(false);
 		/* send our version string */
 		this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
 		/* Send server tree */
 		this->SendServers(TreeRoot,s,1);
-		ServerInstance->DoOneIteration(false);
 		/* Send users and their oper status */
 		this->SendUsers(s);
-		ServerInstance->DoOneIteration(false);
 		/* Send everything else (channel modes, xlines etc) */
 		this->SendChannelModes(s);
-		ServerInstance->DoOneIteration(false);
-		this->SendXLines(s);
-		ServerInstance->DoOneIteration(false);
+		this->SendXLines(s);		
 		FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
-		ServerInstance->DoOneIteration(false);
 		this->WriteLine(endburst);
-		Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2.");
+		Srv->SendOpers("*** Finished bursting to \2"+name+"\2.");
 	}
 
 	/* This function is called when we receive data from a remote
@@ -1442,7 +1829,6 @@ class TreeSocket : public InspSocket
 	 */
 	virtual bool OnDataReady()
 	{
-		int iterations = 0;
 		char* data = this->Read();
 		/* Check that the data read is a valid pointer and it has some content */
 		if (data && *data)
@@ -1453,11 +1839,6 @@ class TreeSocket : public InspSocket
 			 */
 			while (in_buffer.find("\n") != std::string::npos)
 			{
-				iterations++;
-				if ((iterations % 10) == 0)
-				{
-					ServerInstance->DoOneIteration(false);
-				}
 				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"));
 				if (ret.find("\r") != std::string::npos)
@@ -1536,6 +1917,43 @@ class TreeSocket : public InspSocket
 		return false;
 	}
 
+	bool Stats(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
+		 */
+		if (params.size() > 1)
+		{
+			if (Srv->MatchText(Srv->GetServerName(), params[1]))
+			{
+				/* It's for our server */
+				string_list results;
+				userrec* source = Srv->FindNick(prefix);
+				if (source)
+				{
+					std::deque<std::string> par;
+					par.push_back(prefix);
+					par.push_back("");
+					DoStats(*(params[0].c_str()), source, results);
+					for (size_t i = 0; i < results.size(); i++)
+					{
+						par[1] = "::" + results[i];
+						DoOneToOne(Srv->GetServerName(), "PUSH",par, source->server);
+					}
+				}
+			}
+			else
+			{
+				/* Pass it on */
+				userrec* source = Srv->FindNick(prefix);
+				if (source)
+					DoOneToOne(prefix, "STATS", params, params[1]);
+			}
+		}
+		return true;
+	}
+
+
 	/* Because the core won't let users or even SERVERS set +o,
 	 * we use the OPERTYPE command to do this.
 	 */
@@ -1550,11 +1968,8 @@ class TreeSocket : public InspSocket
 		userrec* u = Srv->FindNick(prefix);
 		if (u)
 		{
+			u->modes[UM_OPERATOR] = 1;
 			strlcpy(u->oper,opertype.c_str(),NICKMAX-1);
-			if (!strchr(u->modes,'o'))
-			{
-				strcat(u->modes,"o");
-			}
 			DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
 		}
 		return true;
@@ -1577,7 +1992,9 @@ class TreeSocket : public InspSocket
 			{
 				std::deque<std::string> par;
 				par.push_back(params[1]);
-				DoOneToMany(u->nick,"NICK",par);
+				/* This is not required as one is sent in OnUserPostNick below
+				 */
+				//DoOneToMany(u->nick,"NICK",par);
 				Srv->ChangeUserNick(u,params[1]);
 				u->age = atoi(params[2].c_str());
 			}
@@ -1641,6 +2058,7 @@ class TreeSocket : public InspSocket
 			std::string reason = params[1];
 			params[1] = ":" + params[1];
 			DoOneToAllButSender(prefix,"KILL",params,sourceserv);
+			::Write(who->fd, ":%s KILL %s :%s (%s)", sourceserv.c_str(), who->nick, sourceserv.c_str(), reason.c_str());
 			Srv->QuitUser(who,reason);
 		}
 		return true;
@@ -1765,19 +2183,19 @@ class TreeSocket : public InspSocket
 		{
 			case 'Z':
 				propogate = add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
-				zline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+				zline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
 			break;
 			case 'Q':
 				propogate = add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
-				qline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+				qline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
 			break;
 			case 'E':
 				propogate = add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
-				eline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+				eline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
 			break;
 			case 'G':
 				propogate = add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
-				gline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
+				gline_set_creation_time(params[1].c_str(), atoi(params[3].c_str()));
 			break;
 			case 'K':
 				propogate = add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
@@ -1842,7 +2260,7 @@ class TreeSocket : public InspSocket
 			if (params.size() == 1)
 			{
 				userrec* x = Srv->FindNick(params[0]);
-				if ((x) && (x->fd > -1))
+				if ((x) && (IS_LOCAL(x)))
 				{
 					userrec* x = Srv->FindNick(params[0]);
 					log(DEBUG,"Got IDLE");
@@ -1868,15 +2286,15 @@ class TreeSocket : public InspSocket
 			{
 				std::string who_did_the_whois = params[0];
 				userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
-				if ((who_to_send_to) && (who_to_send_to->fd > -1))
+				if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
 				{
 					log(DEBUG,"Got final IDLE");
 					// an incoming reply to a whois we sent out
 					std::string nick_whoised = prefix;
 					unsigned long signon = atoi(params[1].c_str());
 					unsigned long idle = atoi(params[2].c_str());
-					if ((who_to_send_to) && (who_to_send_to->fd > -1))
-						do_whois(who_to_send_to,u,signon,idle,(char*)nick_whoised.c_str());
+					if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
+						do_whois(who_to_send_to,u,signon,idle,nick_whoised.c_str());
 				}
 				else
 				{
@@ -1895,17 +2313,12 @@ class TreeSocket : public InspSocket
 
 		userrec* u = Srv->FindNick(params[0]);
 
+		if (!u)
+			return true;
+
 		if (IS_LOCAL(u))
 		{
-			// push the raw to the user
-			if (Srv->IsUlined(prefix))
-			{
-				::Write(u->fd,"%s",params[1].c_str());
-			}
-			else
-			{
-				log(DEBUG,"PUSH from non-ulined server dropped into the bit-bucket:  :%s PUSH %s :%s",prefix.c_str(),params[0].c_str(),params[1].c_str());
-			}
+			::Write(u->fd,"%s",params[1].c_str());
 		}
 		else
 		{
@@ -2015,8 +2428,8 @@ class TreeSocket : public InspSocket
 		TreeServer* CheckDupe = FindServer(servername);
 		if (CheckDupe)
 		{
-			this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
-			Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+			this->WriteLine("ERROR :Server "+servername+" already exists!");
+			Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists");
 			return false;
 		}
 		TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
@@ -2032,14 +2445,15 @@ class TreeSocket : public InspSocket
 		if (params.size() < 4)
 			return false;
 
-		std::string servername = params[0];
+		irc::string servername = params[0].c_str();
+		std::string sname = params[0];
 		std::string password = params[1];
 		int hops = atoi(params[2].c_str());
 
 		if (hops)
 		{
 			this->WriteLine("ERROR :Server too far away for authentication");
-			Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
+			Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
 			return false;
 		}
 		std::string description = params[3];
@@ -2047,11 +2461,11 @@ class TreeSocket : public InspSocket
 		{
 			if ((x->Name == servername) && (x->RecvPass == password))
 			{
-				TreeServer* CheckDupe = FindServer(servername);
+				TreeServer* CheckDupe = FindServer(sname);
 				if (CheckDupe)
 				{
-					this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
-					Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+					this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+					Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
 					return false;
 				}
 				// Begin the sync here. this kickstarts the
@@ -2062,17 +2476,17 @@ 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(servername,description,TreeRoot,this);
+				TreeServer* Node = new TreeServer(sname,description,TreeRoot,this);
 				TreeRoot->AddChild(Node);
 				params[3] = ":" + params[3];
-				DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
+				DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,sname);
 				this->bursting = true;
 				this->DoBurst(Node);
 				return true;
 			}
 		}
 		this->WriteLine("ERROR :Invalid credentials");
-		Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
+		Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
 		return false;
 	}
 
@@ -2081,14 +2495,15 @@ class TreeSocket : public InspSocket
 		if (params.size() < 4)
 			return false;
 
-		std::string servername = params[0];
+		irc::string servername = params[0].c_str();
+		std::string sname = params[0];
 		std::string password = params[1];
 		int hops = atoi(params[2].c_str());
 
 		if (hops)
 		{
 			this->WriteLine("ERROR :Server too far away for authentication");
-			Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
+			Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
 			return false;
 		}
 		std::string description = params[3];
@@ -2096,11 +2511,11 @@ class TreeSocket : public InspSocket
 		{
 			if ((x->Name == servername) && (x->RecvPass == password))
 			{
-				TreeServer* CheckDupe = FindServer(servername);
+				TreeServer* CheckDupe = FindServer(sname);
 				if (CheckDupe)
 				{
-					this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
-					Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+					this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
+					Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
 					return false;
 				}
 				/* If the config says this link is encrypted, but the remote side
@@ -2110,11 +2525,11 @@ class TreeSocket : public InspSocket
 				if ((x->EncryptionKey != "") && (!this->ctx_in))
 				{
 					this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused.");
-					Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, remote server did not enable AES.");
+					Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, remote server did not enable AES.");
 					return false;
 				}
-				Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
-				this->InboundServerName = servername;
+				Srv->SendOpers("*** Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
+				this->InboundServerName = sname;
 				this->InboundDescription = description;
 				// this is good. Send our details: Our server name and description and hopcount of 0,
 				// along with the sendpass from this block.
@@ -2125,112 +2540,44 @@ class TreeSocket : public InspSocket
 			}
 		}
 		this->WriteLine("ERROR :Invalid credentials");
-		Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
+		Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
 		return false;
 	}
 
-	void Split(std::string line, bool stripcolon, std::deque<std::string> &n)
+	void Split(std::string line, std::deque<std::string> &n)
 	{
-		// we don't do anything with a line > 2048
-		if (line.length() > 2048)
-		{
-			log(DEBUG,"Line too long!");
-			return;
-		}
-		if (!strchr(line.c_str(),' '))
-		{
-			n.push_back(line);
-			return;
-		}
-		std::stringstream s(line);
-		int count = 0;
-		char param[1024];
-		char* pptr = param;
-
 		n.clear();
-		int item = 0;
-		while (!s.eof())
-		{
-			char c = 0;
-			s.get(c);
-			if (c == ' ')
-			{
-				*pptr = 0;
-				if (*param)
-					n.push_back(param);
-				*param = count = 0;
-				pptr = param;
-				item++;
-			}
-			else
-			{
-				if (!s.eof())
-				{
-					*pptr++ = c;
-					count++;
-				}
-				if ((*param == ':') && (count == 1) && (item > 0))
-				{
-					*param = count = 0;
-					pptr = param;
-					while (!s.eof())
-					{
-						s.get(c);
-						if (!s.eof())
-						{
-							*pptr++ = c;
-							count++;
-						}
-					}
-					*pptr = 0;
-					n.push_back(param);
-					*param = count = 0;
-					pptr = param;
-				}
-			}
-		}
-		*pptr = 0;
-		if (*param)
-		{
+		irc::tokenstream tokens(line);
+		std::string param;
+		while ((param = tokens.GetToken()) != "")
 			n.push_back(param);
-		}
-
 		return;
 	}
 
 	bool ProcessLine(std::string line)
 	{
-		char* l = (char*)line.c_str();
-		for (char* x = l; *x; x++)
-		{
-			if ((*x == '\r') || (*x == '\n'))
-				*x = 0;
-		}
-		if (!*l)
-			return true;
-
-		log(DEBUG,"IN: %s",l);
-
 		std::deque<std::string> params;
-		this->Split(l,true,params);
-		irc::string command = "";
-		std::string prefix = "";
-		if (((params[0].c_str())[0] == ':') && (params.size() > 1))
-		{
-			prefix = params[0];
-			command = params[1].c_str();
-			char* pref = (char*)prefix.c_str();
-			prefix = ++pref;
-			params.pop_front();
-			params.pop_front();
-		}
-		else
+		irc::string command;
+		std::string prefix;
+		
+		if (line.empty())
+			return true;
+		
+		line = line.substr(0, line.find_first_of("\r\n"));
+		
+		log(DEBUG,"IN: %s", line.c_str());
+		
+		this->Split(line.c_str(),params);
+			
+		if ((params[0][0] == ':') && (params.size() > 1))
 		{
-			prefix = "";
-			command = params[0].c_str();
+			prefix = params[0].substr(1);
 			params.pop_front();
 		}
 
+		command = params[0].c_str();
+		params.pop_front();
+
 		if ((!this->ctx_in) && (command == "AES"))
 		{
 			std::string sserv = params[0];
@@ -2413,6 +2760,10 @@ class TreeSocket : public InspSocket
 				{
 					return this->ForceJoin(prefix,params);
 				}
+				else if (command == "STATS")
+				{
+					return this->Stats(prefix, params);
+				}
 				else if (command == "SERVER")
 				{
 					return this->RemoteServer(prefix,params);
@@ -2576,22 +2927,14 @@ class TreeSocket : public InspSocket
 					}
 					if (who)
 					{
-						if (command == "QUIT")
-						{
-							TreeServer* s = FindServer(who->server);
-							if (s)
-							{
-								s->DelUser(who);
-							}
-						}
-						else if ((command == "NICK") && (params.size() > 0))
+						if ((command == "NICK") && (params.size() > 0))
 						{
 							/* On nick messages, check that the nick doesnt
 							 * already exist here. If it does, kill their copy,
 							 * and our copy.
 							 */
 							userrec* x = Srv->FindNick(params[0]);
-							if (x)
+							if ((x) && (x != who))
 							{
 								std::deque<std::string> p;
 								p.push_back(params[0]);
@@ -2612,10 +2955,10 @@ class TreeSocket : public InspSocket
 						}
 						// its a user
 						target = who->server;
-						char* strparams[127];
+						const char* strparams[127];
 						for (unsigned int q = 0; q < params.size(); q++)
 						{
-							strparams[q] = (char*)params[q].c_str();
+							strparams[q] = params[q].c_str();
 						}
 						if (!Srv->CallCommandHandler(command.c_str(), strparams, params.size(), who))
 						{
@@ -2683,6 +3026,38 @@ class TreeSocket : public InspSocket
 
 	virtual int OnIncomingConnection(int newsock, char* ip)
 	{
+		/* To prevent anyone from attempting to flood opers/DDoS by connecting to the server port,
+		 * or discovering if this port is the server port, we don't allow connections from any
+		 * IPs for which we don't have a link block.
+		 */
+		bool found = false;
+		char resolved_host[MAXBUF];
+		vector<Link>::iterator i;
+		for (i = LinkBlocks.begin(); i != LinkBlocks.end(); i++)
+		{
+			if (i->IPAddr == ip)
+			{
+				found = true;
+				break;
+			}
+			/* XXX: Fixme: blocks for a very short amount of time,
+			 * we should cache these on rehash/startup
+			 */
+			if (CleanAndResolve(resolved_host,i->IPAddr.c_str(),true,1))
+			{
+				if (std::string(resolved_host) == ip)
+				{
+					found = true;
+					break;
+				}
+			}
+		}
+		if (!found)
+		{
+			WriteOpers("Server connection from %s denied (no link blocks with that IP address)", ip);
+			close(newsock);
+			return false;
+		}
 		TreeSocket* s = new TreeSocket(newsock, ip);
 		Srv->AddSocket(s);
 		return true;
@@ -2722,14 +3097,14 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 	TreeServer* omitroute = BestRouteTo(omit);
 	if ((command == "NOTICE") || (command == "PRIVMSG"))
 	{
-		if ((params.size() >= 2) && (*(params[0].c_str()) != '$'))
+		if (params.size() >= 2)
 		{
 			/* Prefixes */
 			if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+'))
 			{
 				params[0] = params[0].substr(1, params[0].length()-1);
 			}
-			if (*(params[0].c_str()) != '#')
+			if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$'))
 			{
 				// special routing for private messages/notices
 				userrec* d = Srv->FindNick(params[0]);
@@ -2742,6 +3117,14 @@ bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string pref
 					return true;
 				}
 			}
+			else if (*(params[0].c_str()) == '$')
+			{
+				std::deque<std::string> par;
+				par.push_back(params[0]);
+				par.push_back(":"+params[1]);
+				DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName());
+				return true;
+			}
 			else
 			{
 				log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str());
@@ -2878,7 +3261,7 @@ void ReadConfiguration(bool rebind)
 				{
 					log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port);
 					listener->Close();
-					delete listener;
+					DELETE(listener);
 				}
 			}
 		}
@@ -2889,11 +3272,7 @@ void ReadConfiguration(bool rebind)
 	for (int j =0; j < Conf->Enumerate("link"); j++)
 	{
 		Link L;
-		char ServerN[MAXBUF];
-		L.Name = Conf->ReadValue("link","name",j);
-		strlcpy(ServerN,L.Name.c_str(),MAXBUF);
-		strlower(ServerN);
-		L.Name = ServerN;
+		L.Name = (Conf->ReadValue("link","name",j)).c_str();
 		L.IPAddr = Conf->ReadValue("link","ipaddr",j);
 		L.Port = Conf->ReadInteger("link","port",j,true);
 		L.SendPass = Conf->ReadValue("link","sendpass",j);
@@ -2903,14 +3282,18 @@ void ReadConfiguration(bool rebind)
 		L.HiddenFromStats = Conf->ReadFlag("link","hidden",j);
 		L.NextConnectTime = time(NULL) + L.AutoConnect;
 		/* Bugfix by brain, do not allow people to enter bad configurations */
-		if ((L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port))
+		if ((L.IPAddr != "") && (L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port))
 		{
 			LinkBlocks.push_back(L);
 			log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port);
 		}
 		else
 		{
-			if (L.RecvPass == "")
+			if (L.IPAddr == "")
+			{
+				log(DEFAULT,"Invalid configuration for server '%s', IP address not defined!",L.Name.c_str());
+			}
+			else if (L.RecvPass == "")
 			{
 				log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str());
 			}
@@ -2928,7 +3311,7 @@ void ReadConfiguration(bool rebind)
 			}
 		}
 	}
-	delete Conf;
+	DELETE(Conf);
 }
 
 
@@ -2995,14 +3378,14 @@ class ModuleSpanningTree : public Module
 		return serverlist.size();
 	}
 
-	void HandleLinks(char** parameters, int pcnt, userrec* user)
+	void HandleLinks(const char** parameters, int pcnt, userrec* user)
 	{
 		ShowLinks(TreeRoot,user,0);
 		WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
 		return;
 	}
 
-	void HandleLusers(char** parameters, int pcnt, userrec* user)
+	void HandleLusers(const char** parameters, int pcnt, userrec* user)
 	{
 		unsigned int n_users = usercnt();
 
@@ -3013,9 +3396,12 @@ class ModuleSpanningTree : public Module
 			max_global = n_users;
 
 		WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-usercount_invisible(),usercount_invisible(),this->CountServs());
-		WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
-		WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
-		WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
+		if (usercount_opers())
+			WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
+		if (usercount_unknown())
+			WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
+		if (chancount())
+			WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
 		WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),this->CountLocalServs());
 		WriteServ(user->fd,"265 %s :Current Local Users: %d  Max: %d",user->nick,local_count(),max_local);
 		WriteServ(user->fd,"266 %s :Current Global Users: %d  Max: %d",user->nick,n_users,max_global);
@@ -3078,6 +3464,26 @@ class ModuleSpanningTree : public Module
 		}
 	}
 
+	int HandleStats(const char** parameters, int pcnt, userrec* user)
+	{
+		if (pcnt > 1)
+		{
+			/* Remote STATS, the server is within the 2nd parameter */
+			std::deque<std::string> params;
+			params.push_back(parameters[0]);
+			params.push_back(parameters[1]);
+			/* Send it out remotely, generate no reply yet */
+			TreeServer* s = FindServerMask(parameters[1]);
+			if (s)
+			{
+				params[1] = s->GetName();
+				DoOneToOne(user->nick, "STATS", params, s->GetName());
+			}
+			return 1;
+		}
+		return 0;
+	}
+
 	// Ok, prepare to be confused.
 	// After much mulling over how to approach this, it struck me that
 	// the 'usual' way of doing a /MAP isnt the best way. Instead of
@@ -3087,7 +3493,7 @@ class ModuleSpanningTree : public Module
 	// (a character matrix), then draw the branches as a series of "L" shapes
 	// from the nodes. This is not only friendlier on CPU it uses less stack.
 
-	void HandleMap(char** parameters, int pcnt, userrec* user)
+	void HandleMap(const char** parameters, int pcnt, userrec* user)
 	{
 		// This array represents a virtual screen which we will
 		// "scratch" draw to, as the console device of an irc
@@ -3143,7 +3549,7 @@ class ModuleSpanningTree : public Module
 		return;
 	}
 
-	int HandleSquit(char** parameters, int pcnt, userrec* user)
+	int HandleSquit(const char** parameters, int pcnt, userrec* user)
 	{
 		TreeServer* s = FindServerMask(parameters[0]);
 		if (s)
@@ -3173,9 +3579,9 @@ class ModuleSpanningTree : public Module
 		return 1;
 	}
 
-	int HandleTime(char** parameters, int pcnt, userrec* user)
+	int HandleTime(const char** parameters, int pcnt, userrec* user)
 	{
-		if ((user->fd > -1) && (pcnt))
+		if ((IS_LOCAL(user)) && (pcnt))
 		{
 			TreeServer* found = FindServerMask(parameters[0]);
 			if (found)
@@ -3197,9 +3603,9 @@ class ModuleSpanningTree : public Module
 		return 1;
 	}
 
-	int HandleRemoteWhois(char** parameters, int pcnt, userrec* user)
+	int HandleRemoteWhois(const char** parameters, int pcnt, userrec* user)
 	{
-		if ((user->fd > -1) && (pcnt > 1))
+		if ((IS_LOCAL(user)) && (pcnt > 1))
 		{
 			userrec* remote = Srv->FindNick(parameters[1]);
 			if ((remote) && (remote->fd < 0))
@@ -3255,27 +3661,27 @@ class ModuleSpanningTree : public Module
 			{
 				log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
 				x->NextConnectTime = curtime + x->AutoConnect;
-				TreeServer* CheckDupe = FindServer(x->Name);
+				TreeServer* CheckDupe = FindServer(x->Name.c_str());
 				if (!CheckDupe)
 				{
 					// an autoconnected server is not connected. Check if its time to connect it
 					WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
-					TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
-					if (newsocket->GetState() != I_ERROR)
+					TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str());
+					if (newsocket->GetFd() > -1)
 					{
 						Srv->AddSocket(newsocket);
 					}
 					else
 					{
-						WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002.",x->Name.c_str());
-						delete newsocket;
+						WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+						DELETE(newsocket);
 					}
 				}
 			}
 		}
 	}
 
-	int HandleVersion(char** parameters, int pcnt, userrec* user)
+	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]);
@@ -3312,25 +3718,25 @@ class ModuleSpanningTree : public Module
 		return 1;
 	}
 	
-	int HandleConnect(char** parameters, int pcnt, userrec* user)
+	int HandleConnect(const char** parameters, int pcnt, userrec* user)
 	{
 		for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
 		{
 			if (Srv->MatchText(x->Name.c_str(),parameters[0]))
 			{
-				TreeServer* CheckDupe = FindServer(x->Name);
+				TreeServer* CheckDupe = FindServer(x->Name.c_str());
 				if (!CheckDupe)
 				{
 					WriteServ(user->fd,"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);
-					TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
-					if (newsocket->GetState() != I_ERROR)
+					TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name.c_str());
+					if (newsocket->GetFd() > -1)
 					{
 						Srv->AddSocket(newsocket);
 					}
 					else
 					{
-						WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002.",user->nick,x->Name.c_str());
-						delete newsocket;
+						WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002: %s.",user->nick,x->Name.c_str(),strerror(errno));
+						DELETE(newsocket);
 					}
 					return 1;
 				}
@@ -3345,23 +3751,23 @@ class ModuleSpanningTree : public Module
 		return 1;
 	}
 
-	virtual int OnStats(char statschar, userrec* user)
+	virtual int OnStats(char statschar, userrec* user, string_list &results)
 	{
 		if (statschar == 'c')
 		{
 			for (unsigned int i = 0; i < LinkBlocks.size(); i++)
 			{
-				WriteServ(user->fd,"213 %s C *@%s * %s %d 0 %c%c%c",user->nick,(LinkBlocks[i].HiddenFromStats ? "<hidden>" : LinkBlocks[i].IPAddr).c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-'),(LinkBlocks[i].AutoConnect ? 'a' : '-'),'s');
-				WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str());
+				results.push_back(Srv->GetServerName()+" 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(Srv->GetServerName()+" 244 "+user->nick+" H * * "+LinkBlocks[i].Name.c_str());
 			}
-			WriteServ(user->fd,"219 %s %c :End of /STATS report",user->nick,statschar);
-			WriteOpers("*** Notice: Stats '%c' requested by %s (%s@%s)",statschar,user->nick,user->ident,user->host);
+			results.push_back(Srv->GetServerName()+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
+			WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
 			return 1;
 		}
 		return 0;
 	}
 
-	virtual int OnPreCommand(const std::string &command, char **parameters, int pcnt, userrec *user, bool validated)
+	virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated)
 	{
 		/* If the command doesnt appear to be valid, we dont want to mess with it. */
 		if (!validated)
@@ -3371,6 +3777,10 @@ class ModuleSpanningTree : public Module
 		{
 			return this->HandleConnect(parameters,pcnt,user);
 		}
+		else if (command == "STATS")
+		{
+			return this->HandleStats(parameters,pcnt,user);
+		}
 		else if (command == "SQUIT")
 		{
 			return this->HandleSquit(parameters,pcnt,user);
@@ -3444,7 +3854,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
 	{
-		if (source->fd > -1)
+		if (IS_LOCAL(source))
 		{
 			std::deque<std::string> params;
 			params.push_back(dest->nick);
@@ -3463,7 +3873,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnWallops(userrec* user, const std::string &text)
 	{
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			params.push_back(":"+text);
@@ -3476,7 +3886,7 @@ class ModuleSpanningTree : public Module
 		if (target_type == TYPE_USER)
 		{
 			userrec* d = (userrec*)dest;
-			if ((d->fd < 0) && (user->fd > -1))
+			if ((d->fd < 0) && (IS_LOCAL(user)))
 			{
 				std::deque<std::string> params;
 				params.clear();
@@ -3485,9 +3895,9 @@ class ModuleSpanningTree : public Module
 				DoOneToOne(user->nick,"NOTICE",params,d->server);
 			}
 		}
-		else
+		else if (target_type == TYPE_CHANNEL)
 		{
-			if (user->fd > -1)
+			if (IS_LOCAL(user))
 			{
 				chanrec *c = (chanrec*)dest;
 				std::string cname = c->name;
@@ -3504,6 +3914,17 @@ class ModuleSpanningTree : public Module
 				}
 			}
 		}
+                else if (target_type == TYPE_SERVER)
+		{
+			if (IS_LOCAL(user))
+			{
+				char* target = (char*)dest;
+				std::deque<std::string> par;
+				par.push_back(target);
+				par.push_back(":"+text);
+				DoOneToMany(user->nick,"NOTICE",par);
+			}
+		}
 	}
 
 	virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status)
@@ -3513,7 +3934,7 @@ class ModuleSpanningTree : public Module
 			// route private messages which are targetted at clients only to the server
 			// which needs to receive them
 			userrec* d = (userrec*)dest;
-			if ((d->fd < 0) && (user->fd > -1))
+			if ((d->fd < 0) && (IS_LOCAL(user)))
 			{
 				std::deque<std::string> params;
 				params.clear();
@@ -3522,9 +3943,9 @@ class ModuleSpanningTree : public Module
 				DoOneToOne(user->nick,"PRIVMSG",params,d->server);
 			}
 		}
-		else
+		else if (target_type == TYPE_CHANNEL)
 		{
-			if (user->fd > -1)
+			if (IS_LOCAL(user))
 			{
 				chanrec *c = (chanrec*)dest;
 				std::string cname = c->name;
@@ -3541,6 +3962,17 @@ class ModuleSpanningTree : public Module
 				}
 			}
 		}
+		else if (target_type == TYPE_SERVER)
+		{
+			if (IS_LOCAL(user))
+			{
+				char* target = (char*)dest;
+				std::deque<std::string> par;
+				par.push_back(target);
+				par.push_back(":"+text);
+				DoOneToMany(user->nick,"PRIVMSG",par);
+			}
+		}
 	}
 
 	virtual void OnBackgroundTimer(time_t curtime)
@@ -3552,16 +3984,12 @@ class ModuleSpanningTree : public Module
 	virtual void OnUserJoin(userrec* user, chanrec* channel)
 	{
 		// Only do this for local users
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			params.clear();
 			params.push_back(channel->name);
-			if (*channel->key)
-			{
-				// if the channel has a key, force the join by emulating the key.
-				params.push_back(channel->key);
-			}
+
 			if (channel->GetUserCounter() > 1)
 			{
 				// not the first in the channel
@@ -3585,7 +4013,7 @@ class ModuleSpanningTree : public Module
 	virtual void OnChangeHost(userrec* user, const std::string &newhost)
 	{
 		// only occurs for local clients
-		if (user->registered != 7)
+		if (user->registered != REG_ALL)
 			return;
 		std::deque<std::string> params;
 		params.push_back(newhost);
@@ -3595,7 +4023,7 @@ class ModuleSpanningTree : public Module
 	virtual void OnChangeName(userrec* user, const std::string &gecos)
 	{
 		// only occurs for local clients
-		if (user->registered != 7)
+		if (user->registered != REG_ALL)
 			return;
 		std::deque<std::string> params;
 		params.push_back(gecos);
@@ -3604,7 +4032,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage)
 	{
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			params.push_back(channel->name);
@@ -3617,7 +4045,7 @@ class ModuleSpanningTree : public Module
 	virtual void OnUserConnect(userrec* user)
 	{
 		char agestr[MAXBUF];
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
@@ -3626,8 +4054,8 @@ class ModuleSpanningTree : public Module
 			params.push_back(user->host);
 			params.push_back(user->dhost);
 			params.push_back(user->ident);
-			params.push_back("+"+std::string(user->modes));
-			params.push_back((char*)inet_ntoa(user->ip4));
+			params.push_back("+"+std::string(user->FormatModes()));
+			params.push_back((char*)insp_ntoa(user->ip4));
 			params.push_back(":"+std::string(user->fullname));
 			DoOneToMany(Srv->GetServerName(),"NICK",params);
 
@@ -3643,7 +4071,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnUserQuit(userrec* user, const std::string &reason)
 	{
-		if ((user->fd > -1) && (user->registered == 7))
+		if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
 		{
 			std::deque<std::string> params;
 			params.push_back(":"+reason);
@@ -3660,7 +4088,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnUserPostNick(userrec* user, const std::string &oldnick)
 	{
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			params.push_back(user->nick);
@@ -3670,7 +4098,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason)
 	{
-		if ((source) && (source->fd > -1))
+		if ((source) && (IS_LOCAL(source)))
 		{
 			std::deque<std::string> params;
 			params.push_back(chan->name);
@@ -3718,7 +4146,7 @@ class ModuleSpanningTree : public Module
 	// locally.
 	virtual void OnOper(userrec* user, const std::string &opertype)
 	{
-		if (user->fd > -1)
+		if (IS_LOCAL(user))
 		{
 			std::deque<std::string> params;
 			params.push_back(opertype);
@@ -3728,7 +4156,7 @@ class ModuleSpanningTree : public Module
 
 	void OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason)
 	{
-		if (source->fd > -1)
+		if (IS_LOCAL(source))
 		{
 			char type[8];
 			snprintf(type,8,"%cLINE",linetype);
@@ -3794,7 +4222,7 @@ class ModuleSpanningTree : public Module
 
 	virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text)
 	{
-		if ((user->fd > -1) && (user->registered == 7))
+		if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
 		{
 			if (target_type == TYPE_USER)
 			{
@@ -3843,12 +4271,12 @@ class ModuleSpanningTree : public Module
 			if (target_type == TYPE_USER)
 			{
 				userrec* u = (userrec*)target;
-				s->WriteLine(":"+Srv->GetServerName()+" FMODE "+u->nick+" "+modeline);
+				s->WriteLine(":"+Srv->GetServerName()+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline);
 			}
 			else
 			{
 				chanrec* c = (chanrec*)target;
-				s->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+modeline);
+				s->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline);
 			}
 		}
 	}
@@ -3885,6 +4313,29 @@ class ModuleSpanningTree : public Module
 			(*params)[2] = ":" + (*params)[2];
 			DoOneToMany(Srv->GetServerName(),"METADATA",*params);
 		}
+		else if (event->GetEventID() == "send_mode")
+		{
+			std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
+			if (params->size() < 2)
+				return;
+			// Insert the TS value of the object, either userrec or chanrec
+			time_t ourTS = 0;
+			userrec* a = Srv->FindNick((*params)[0]);
+			if (a)
+			{
+				ourTS = a->age;
+			}
+			else
+			{
+				chanrec* a = Srv->FindChannel((*params)[0]);
+				if (a)
+				{
+					ourTS = a->age;
+				}
+			}
+			params->insert(params->begin() + 1,ConvToStr(ourTS));
+			DoOneToMany(Srv->GetServerName(),"FMODE",*params);
+		}
 	}
 
 	virtual ~ModuleSpanningTree()