X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fusers.cpp;h=286f08fe655573b39de8332cb339b034a86f6833;hb=9ee525bec55521e9d911df40c2d8ca8b0212ee22;hp=5141053bab2e1bb2852c2478a80a218c58b871c3;hpb=b57c7f4e466f72fdd2ac3deca42caa1ea7748338;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/users.cpp b/src/users.cpp
index 5141053ba..286f08fe6 100644
--- a/src/users.cpp
+++ b/src/users.cpp
@@ -2,7 +2,7 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
  * See: http://www.inspircd.org/wiki/index.php/Credits
  *
  * This program is free but copyrighted software; see
@@ -11,11 +11,14 @@
  * ---------------------------------------------------
  */
 
+/* $Core: libIRCDusers */
+
 #include "inspircd.h"
 #include <stdarg.h>
 #include "socketengine.h"
 #include "wildcard.h"
 #include "xline.h"
+#include "bancache.h"
 #include "commands/cmd_whowas.h"
 
 static unsigned long already_sent[MAX_DESCRIPTORS] = {0};
@@ -23,59 +26,6 @@ static unsigned long already_sent[MAX_DESCRIPTORS] = {0};
 /* XXX: Used for speeding up WriteCommon operations */
 unsigned long uniq_id = 0;
 
-bool InitTypes(ServerConfig* conf, const char* tag)
-{
-	if (conf->opertypes.size())
-	{
-		for (opertype_t::iterator n = conf->opertypes.begin(); n != conf->opertypes.end(); n++)
-		{
-			if (n->second)
-				delete[] n->second;
-		}
-	}
-
-	conf->opertypes.clear();
-	return true;
-}
-
-bool InitClasses(ServerConfig* conf, const char* tag)
-{
-	if (conf->operclass.size())
-	{
-		for (operclass_t::iterator n = conf->operclass.begin(); n != conf->operclass.end(); n++)
-		{
-			if (n->second)
-				delete[] n->second;
-		}
-	}
-
-	conf->operclass.clear();
-	return true;
-}
-
-bool DoType(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
-{
-	const char* TypeName = values[0].GetString();
-	const char* Classes = values[1].GetString();
-
-	conf->opertypes[TypeName] = strnewdup(Classes);
-	return true;
-}
-
-bool DoClass(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
-{
-	const char* ClassName = values[0].GetString();
-	const char* CommandList = values[1].GetString();
-
-	conf->operclass[ClassName] = strnewdup(CommandList);
-	return true;
-}
-
-bool DoneClassesAndTypes(ServerConfig* conf, const char* tag)
-{
-	return true;
-}
-
 std::string User::ProcessNoticeMasks(const char *sm)
 {
 	bool adding = true, oldadding = false;
@@ -123,6 +73,9 @@ std::string User::ProcessNoticeMasks(const char *sm)
 						output += *c;
 					}
 				}
+				else
+					this->WriteServ("501 %s %c :is unknown snomask char to me", this->nick, *c);
+
 				oldadding = adding;
 			break;
 		}
@@ -138,125 +91,22 @@ void User::StartDNSLookup()
 	try
 	{
 		bool cached;
-		const char* ip = this->GetIPString();
+		const char* sip = this->GetIPString();
 
 		/* Special case for 4in6 (Have i mentioned i HATE 4in6?) */
-		if (!strncmp(ip, "0::ffff:", 8))
-			res_reverse = new UserResolver(this->ServerInstance, this, ip + 8, DNS_QUERY_PTR4, cached);
+		if (!strncmp(sip, "0::ffff:", 8))
+			res_reverse = new UserResolver(this->ServerInstance, this, sip + 8, DNS_QUERY_PTR4, cached);
 		else
-			res_reverse = new UserResolver(this->ServerInstance, this, ip, this->GetProtocolFamily() == AF_INET ? DNS_QUERY_PTR4 : DNS_QUERY_PTR6, cached);
+			res_reverse = new UserResolver(this->ServerInstance, this, sip, this->GetProtocolFamily() == AF_INET ? DNS_QUERY_PTR4 : DNS_QUERY_PTR6, cached);
 
 		this->ServerInstance->AddResolver(res_reverse, cached);
 	}
 	catch (CoreException& e)
 	{
-		ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
-	}
-}
-
-UserResolver::UserResolver(InspIRCd* Instance, User* user, std::string to_resolve, QueryType qt, bool &cache) :
-	Resolver(Instance, to_resolve, qt, cache), bound_user(user)
-{
-	this->fwd = (qt == DNS_QUERY_A || qt == DNS_QUERY_AAAA);
-	this->bound_fd = user->GetFd();
-}
-
-void UserResolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum)
-{
-	/* We are only interested in the first matching result */
-	if (resultnum)
-		return;
-
-	if ((!this->fwd) && (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user))
-	{
-		this->bound_user->stored_host = result;
-		try
-		{
-			/* Check we didnt time out */
-			if (this->bound_user->registered != REG_ALL)
-			{
-				bool cached;
-#ifdef IPV6
-				if (this->bound_user->GetProtocolFamily() == AF_INET6)
-				{
-					/* IPV6 forward lookup (with possibility of 4in6) */
-					const char* ip = this->bound_user->GetIPString();
-					bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, (!strncmp(ip, "0::ffff:", 8) ? DNS_QUERY_A : DNS_QUERY_AAAA), cached);
-				}
-				else
-					/* IPV4 lookup (mixed protocol mode) */
-#endif
-				/* IPV4 lookup (ipv4 only mode) */
-				bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A, cached);
-				this->ServerInstance->AddResolver(bound_user->res_forward, cached);
-			}
-		}
-		catch (CoreException& e)
-		{
-			ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
-		}
-	}
-	else if ((this->fwd) && (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user))
-	{
-		/* Both lookups completed */
-		std::string result2("0::ffff:");
-		result2.append(result);
-		if (this->bound_user->GetIPString() == result || this->bound_user->GetIPString() == result2)
-		{
-			std::string hostname = this->bound_user->stored_host;
-			if (hostname.length() < 65)
-			{
-				/* Check we didnt time out */
-				if ((this->bound_user->registered != REG_ALL) && (!this->bound_user->dns_done))
-				{
-					/* Hostnames starting with : are not a good thing (tm) */
-					if (*(hostname.c_str()) == ':')
-						hostname.insert(0, "0");
-
-					this->bound_user->WriteServ("NOTICE Auth :*** Found your hostname (%s)%s", hostname.c_str(), (cached ? " -- cached" : ""));
-					this->bound_user->dns_done = true;
-					strlcpy(this->bound_user->dhost, hostname.c_str(),64);
-					strlcpy(this->bound_user->host, hostname.c_str(),64);
-					/* Invalidate cache */
-					this->bound_user->InvalidateCache();
-				}
-			}
-			else
-			{
-				if (!this->bound_user->dns_done)
-				{
-					this->bound_user->WriteServ("NOTICE Auth :*** Your hostname is longer than the maximum of 64 characters, using your IP address (%s) instead.", this->bound_user->GetIPString());
-					this->bound_user->dns_done = true;
-				}
-			}
-		}
-		else
-		{
-			if (!this->bound_user->dns_done)
-			{
-				this->bound_user->WriteServ("NOTICE Auth :*** Your hostname does not match up with your IP address. Sorry, using your IP address (%s) instead.", this->bound_user->GetIPString());
-				this->bound_user->dns_done = true;
-			}
-		}
-	}
-}
-
-void UserResolver::OnError(ResolverError e, const std::string &errormessage)
-{
-	if (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user)
-	{
-		/* Since dns timeout is implemented outside of the resolver, this was a race condition that could result in this message being sent *after*
-		 * the user was fully connected. This check fixes that issue  - Special */
-		if (!this->bound_user->dns_done)
-		{
-			/* Error message here */
-			this->bound_user->WriteServ("NOTICE Auth :*** Could not resolve your hostname: %s; using your IP address (%s) instead.", errormessage.c_str(), this->bound_user->GetIPString());
-			this->bound_user->dns_done = true;
-		}
+		ServerInstance->Logs->Log("USERS", DEBUG,"Error in resolver: %s",e.GetReason());
 	}
 }
 
-
 bool User::IsNoticeMaskSet(unsigned char sm)
 {
 	return (snomasks[sm-65]);
@@ -309,16 +159,16 @@ const char* User::FormatModes()
 
 void User::DecrementModes()
 {
-	ServerInstance->Log(DEBUG,"DecrementModes()");
+	ServerInstance->Logs->Log("USERS", DEBUG, "DecrementModes()");
 	for (unsigned char n = 'A'; n <= 'z'; n++)
 	{
 		if (modes[n-65])
 		{
-			ServerInstance->Log(DEBUG,"DecrementModes() found mode %c", n);
+			ServerInstance->Logs->Log("USERS", DEBUG,"DecrementModes() found mode %c", n);
 			ModeHandler* mh = ServerInstance->Modes->FindMode(n, MODETYPE_USER);
 			if (mh)
 			{
-				ServerInstance->Log(DEBUG,"Found handler %c and call ChangeCount", n);
+				ServerInstance->Logs->Log("USERS", DEBUG,"Found handler %c and call ChangeCount", n);
 				mh->ChangeCount(-1);
 			}
 		}
@@ -330,10 +180,11 @@ User::User(InspIRCd* Instance, const std::string &uid) : ServerInstance(Instance
 	*password = *nick = *ident = *host = *dhost = *fullname = *awaymsg = *oper = *uuid = 0;
 	server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName);
 	reset_due = ServerInstance->Time();
-	age = ServerInstance->Time(true);
+	age = ServerInstance->Time();
+	Penalty = 0;
 	lines_in = lastping = signon = idle_lastmsg = nping = registered = 0;
-	ChannelCount = timeout = flood = bytes_in = bytes_out = cmds_in = cmds_out = 0;
-	muted = exempt = haspassed = dns_done = false;
+	ChannelCount = timeout = bytes_in = bytes_out = cmds_in = cmds_out = 0;
+	quietquit = OverPenalty = ExemptFromPenalty = quitting = exempt = haspassed = dns_done = false;
 	fd = -1;
 	recvq.clear();
 	sendq.clear();
@@ -341,59 +192,49 @@ User::User(InspIRCd* Instance, const std::string &uid) : ServerInstance(Instance
 	res_forward = res_reverse = NULL;
 	Visibility = NULL;
 	ip = NULL;
+	MyClass = NULL;
+	AllowedOperCommands = NULL;
 	chans.clear();
 	invites.clear();
 	memset(modes,0,sizeof(modes));
 	memset(snomasks,0,sizeof(snomasks));
 	/* Invalidate cache */
-	operquit = cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL;
+	cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL;
 
 	if (uid.empty())
 		strlcpy(uuid, Instance->GetUID().c_str(), UUID_LENGTH);
 	else
 		strlcpy(uuid, uid.c_str(), UUID_LENGTH);
 
-	ServerInstance->Log(DEBUG,"New UUID for user: %s (%s)", uuid, uid.empty() ? "allocated new" : "used remote");
+	ServerInstance->Logs->Log("USERS", DEBUG,"New UUID for user: %s (%s)", uuid, uid.empty() ? "allocated new" : "used remote");
 
-	user_hash::iterator finduuid = Instance->uuidlist->find(uuid);
-	if (finduuid == Instance->uuidlist->end())
-		(*Instance->uuidlist)[uuid] = this;
+	user_hash::iterator finduuid = Instance->Users->uuidlist->find(uuid);
+	if (finduuid == Instance->Users->uuidlist->end())
+		(*Instance->Users->uuidlist)[uuid] = this;
 	else
 		throw CoreException("Duplicate UUID "+std::string(uuid)+" in User constructor");
 }
 
-void User::RemoveCloneCounts()
+User::~User()
 {
-	clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString());
-	if (x != ServerInstance->local_clones.end())
+	/* NULL for remote users :) */
+	if (this->MyClass)
 	{
-		x->second--;
-		if (!x->second)
-		{
-			ServerInstance->local_clones.erase(x);
-		}
+		this->MyClass->RefCount--;
+		ServerInstance->Logs->Log("USERS", DEBUG, "User destructor -- connect refcount now: %u", this->MyClass->RefCount);
 	}
-	
-	clonemap::iterator y = ServerInstance->global_clones.find(this->GetIPString());
-	if (y != ServerInstance->global_clones.end())
+	if (this->AllowedOperCommands)
 	{
-		y->second--;
-		if (!y->second)
-		{
-			ServerInstance->global_clones.erase(y);
-		}
+		delete AllowedOperCommands;
+		AllowedOperCommands = NULL;
 	}
-}
 
-User::~User()
-{
 	this->InvalidateCache();
 	this->DecrementModes();
-	if (operquit)
-		free(operquit);
+
 	if (ip)
 	{
-		this->RemoveCloneCounts();
+		ServerInstance->Users->RemoveCloneCounts(this);
 
 		if (this->GetProtocolFamily() == AF_INET)
 		{
@@ -407,7 +248,7 @@ User::~User()
 #endif
 	}
 
-	ServerInstance->uuidlist->erase(uuid);
+	ServerInstance->Users->uuidlist->erase(uuid);
 }
 
 char* User::MakeHost()
@@ -529,10 +370,20 @@ char* User::GetFullRealHost()
 
 bool User::IsInvited(const irc::string &channel)
 {
-	for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++)
+	time_t now = time(NULL);
+	InvitedList::iterator safei;
+	for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
 	{
-		if (channel == *i)
+		if (channel == i->first)
 		{
+			if (i->second != 0 && now > i->second)
+			{
+				/* Expired invite, remove it. */
+				safei = i;
+				--i;
+				invites.erase(safei);
+				continue;
+			}
 			return true;
 		}
 	}
@@ -541,19 +392,44 @@ bool User::IsInvited(const irc::string &channel)
 
 InvitedList* User::GetInviteList()
 {
+	time_t now = time(NULL);
+	/* Weed out expired invites here. */
+	InvitedList::iterator safei;
+	for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
+	{
+		if (i->second != 0 && now > i->second)
+		{
+			/* Expired invite, remove it. */
+			safei = i;
+			--i;
+			invites.erase(safei);
+		}
+	}
 	return &invites;
 }
 
-void User::InviteTo(const irc::string &channel)
+void User::InviteTo(const irc::string &channel, time_t invtimeout)
 {
-	invites.push_back(channel);
+	time_t now = time(NULL);
+	if (invtimeout != 0 && now > invtimeout) return; /* Don't add invites that are expired from the get-go. */
+	for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i)
+	{
+		if (channel == i->first)
+		{
+			if (i->second != 0 && invtimeout > i->second)
+			{
+				i->second = invtimeout;
+			}
+		}
+	}
+	invites.push_back(std::make_pair(channel, invtimeout));
 }
 
 void User::RemoveInvite(const irc::string &channel)
 {
 	for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++)
 	{
-		if (channel == *i)
+		if (channel == i->first)
 		{
 			invites.erase(i);
 			return;
@@ -563,10 +439,6 @@ void User::RemoveInvite(const irc::string &channel)
 
 bool User::HasPermission(const std::string &command)
 {
-	char* mycmd;
-	char* savept;
-	char* savept2;
-
 	/*
 	 * users on remote servers can completely bypass all permissions based checks.
 	 * This prevents desyncs when one server has different type/class tags to another.
@@ -578,37 +450,19 @@ bool User::HasPermission(const std::string &command)
 		return true;
 
 	// are they even an oper at all?
-	if (IS_OPER(this))
+	if (!IS_OPER(this))
 	{
-		opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper);
-		if (iter_opertype != ServerInstance->Config->opertypes.end())
-		{
-			char* Classes = strdup(iter_opertype->second);
-			char* myclass = strtok_r(Classes," ",&savept);
-			while (myclass)
-			{
-				operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass);
-				if (iter_operclass != ServerInstance->Config->operclass.end())
-				{
-					char* CommandList = strdup(iter_operclass->second);
-					mycmd = strtok_r(CommandList," ",&savept2);
-					while (mycmd)
-					{
-						if ((!strcasecmp(mycmd,command.c_str())) || (*mycmd == '*'))
-						{
-							free(Classes);
-							free(CommandList);
-							return true;
-						}
-						mycmd = strtok_r(NULL," ",&savept2);
-					}
-					free(CommandList);
-				}
-				myclass = strtok_r(NULL," ",&savept);
-			}
-			free(Classes);
-		}
+		return false;
 	}
+
+	if (!AllowedOperCommands)
+		return false;
+
+	if (AllowedOperCommands->find(command) != AllowedOperCommands->end())
+		return true;
+	else if (AllowedOperCommands->find("*") != AllowedOperCommands->end())
+		return true;
+
 	return false;
 }
 
@@ -633,10 +487,10 @@ bool User::AddBuffer(std::string a)
 		if (a.length())
 			recvq.append(a);
 
-		if (recvq.length() > (unsigned)this->recvqmax)
+		if (this->MyClass && (recvq.length() > this->MyClass->GetRecvqMax()))
 		{
 			this->SetWriteError("RecvQ exceeded");
-			ServerInstance->WriteOpers("*** User %s RecvQ of %d exceeds connect class maximum of %d",this->nick,recvq.length(),this->recvqmax);
+			ServerInstance->SNO->WriteToSnoMask('A', "User %s RecvQ of %d exceeds connect class maximum of %d",this->nick,recvq.length(),this->MyClass->GetRecvqMax());
 			return false;
 		}
 
@@ -645,7 +499,7 @@ bool User::AddBuffer(std::string a)
 
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::AddBuffer()");
+		ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::AddBuffer()");
 		return false;
 	}
 }
@@ -664,7 +518,7 @@ std::string User::GetBuffer()
 {
 	try
 	{
-		if (!recvq.length())
+		if (recvq.empty())
 			return "";
 
 		/* Strip any leading \r or \n off the string.
@@ -695,7 +549,7 @@ std::string User::GetBuffer()
 
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::GetBuffer()");
+		ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::GetBuffer()");
 		return "";
 	}
 }
@@ -705,30 +559,22 @@ void User::AddWriteBuf(const std::string &data)
 	if (*this->GetWriteError())
 		return;
 
-	if (sendq.length() + data.length() > (unsigned)this->sendqmax)
+	if (this->MyClass && (sendq.length() + data.length() > this->MyClass->GetSendqMax()))
 	{
 		/*
-		 * Fix by brain - Set the error text BEFORE calling writeopers, because
+		 * Fix by brain - Set the error text BEFORE calling, because
 		 * if we dont it'll recursively  call here over and over again trying
 		 * to repeatedly add the text to the sendq!
 		 */
 		this->SetWriteError("SendQ exceeded");
-		ServerInstance->WriteOpers("*** User %s SendQ of %d exceeds connect class maximum of %d",this->nick,sendq.length() + data.length(),this->sendqmax);
+		ServerInstance->SNO->WriteToSnoMask('A', "User %s SendQ of %d exceeds connect class maximum of %d",this->nick,sendq.length() + data.length(),this->MyClass->GetSendqMax());
 		return;
 	}
 
-	try
-	{
-		if (data.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */
-			sendq.append(data.substr(0,MAXBUF - 4)).append("\r\n"); /* MAXBUF-4 = 510 */
-		else
-			sendq.append(data);
-	}
-	catch (...)
-	{
-		this->SetWriteError("SendQ exceeded");
-		ServerInstance->WriteOpers("*** User %s SendQ got an exception",this->nick);
-	}
+	if (data.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */
+		sendq.append(data.substr(0,MAXBUF - 4)).append("\r\n"); /* MAXBUF-4 = 510 */
+	else
+		sendq.append(data);
 }
 
 // send AS MUCH OF THE USERS SENDQ as we are able to (might not be all of it)
@@ -778,7 +624,7 @@ void User::FlushWriteBuf()
 
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::FlushWriteBuf()");
+		ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::FlushWriteBuf()");
 	}
 
 	if (this->sendq.empty())
@@ -789,17 +635,9 @@ void User::FlushWriteBuf()
 
 void User::SetWriteError(const std::string &error)
 {
-	try
-	{
-		// don't try to set the error twice, its already set take the first string.
-		if (this->WriteError.empty())
-			this->WriteError = error;
-	}
-
-	catch (...)
-	{
-		ServerInstance->Log(DEBUG,"Exception in User::SetWriteError()");
-	}
+	// don't try to set the error twice, its already set take the first string.
+	if (this->WriteError.empty())
+		this->WriteError = error;
 }
 
 const char* User::GetWriteError()
@@ -807,51 +645,108 @@ const char* User::GetWriteError()
 	return this->WriteError.c_str();
 }
 
-void User::Oper(const std::string &opertype)
+void User::Oper(const std::string &opertype, const std::string &opername)
 {
+	char* mycmd;
+	char* savept;
+	char* savept2;
+
 	try
 	{
 		this->modes[UM_OPERATOR] = 1;
 		this->WriteServ("MODE %s :+o", this->nick);
 		FOREACH_MOD(I_OnOper, OnOper(this, opertype));
-		ServerInstance->Log(DEFAULT,"OPER: %s!%s@%s opered as type: %s", this->nick, this->ident, this->host, opertype.c_str());
+		ServerInstance->Logs->Log("OPER", DEFAULT, "%s!%s@%s opered as type: %s", this->nick, this->ident, this->host, opertype.c_str());
 		strlcpy(this->oper, opertype.c_str(), NICKMAX - 1);
-		ServerInstance->all_opers.push_back(this);
-		FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype));
+		ServerInstance->Users->all_opers.push_back(this);
+
+		opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper);
+		if (iter_opertype != ServerInstance->Config->opertypes.end())
+		{
+
+			if (AllowedOperCommands)
+				AllowedOperCommands->clear();
+			else
+				AllowedOperCommands = new std::map<std::string, bool>;
+
+			char* Classes = strdup(iter_opertype->second);
+			char* myclass = strtok_r(Classes," ",&savept);
+			while (myclass)
+			{
+				operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass);
+				if (iter_operclass != ServerInstance->Config->operclass.end())
+				{
+					char* CommandList = strdup(iter_operclass->second);
+					mycmd = strtok_r(CommandList," ",&savept2);
+					while (mycmd)
+					{
+						this->AllowedOperCommands->insert(std::make_pair(mycmd, true));
+						mycmd = strtok_r(NULL," ",&savept2);
+					}
+					free(CommandList);
+				}
+				myclass = strtok_r(NULL," ",&savept);
+			}
+			free(Classes);
+		}
+
+		FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype, opername));
 	}
 
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::Oper()");
+		ServerInstance->Logs->Log("OPER", DEBUG,"Exception in User::Oper()");
 	}
 }
 
 void User::UnOper()
 {
-	try
+	if (IS_OPER(this))
 	{
-		if (IS_OPER(this))
+		/* Remove all oper only modes from the user when the deoper - Bug #466*/
+		std::string moderemove("-");
+
+		for (unsigned char letter = 'A'; letter <= 'z'; letter++)
 		{
-			// unset their oper type (what IS_OPER checks), and remove +o
-			*this->oper = 0;
-			this->modes[UM_OPERATOR] = 0;
-			
-			// remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404
-			ServerInstance->all_opers.remove(this);
+			if (letter != 'o')
+			{
+				ModeHandler* mh = ServerInstance->Modes->FindMode(letter, MODETYPE_USER);
+				if (mh && mh->NeedsOper())
+					moderemove += letter;
+			}
 		}
-	}
 
-	catch (...)
-	{
-		ServerInstance->Log(DEBUG,"Exception in User::UnOper()");
+		const char* parameters[] = { this->nick, moderemove.c_str() };
+		ServerInstance->Parser->CallHandler("MODE", parameters, 2, this);
+
+		/* unset their oper type (what IS_OPER checks), and remove +o */
+		*this->oper = 0;
+		this->modes[UM_OPERATOR] = 0;
+			
+		/* remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 */
+		ServerInstance->Users->all_opers.remove(this);
+
+		if (AllowedOperCommands)
+		{
+			delete AllowedOperCommands;
+			AllowedOperCommands = NULL;
+		}
 	}
 }
 
 void User::QuitUser(InspIRCd* Instance, User *user, const std::string &quitreason, const char* operreason)
 {
-	user->Write("ERROR :Closing link (%s@%s) [%s]", user->ident, user->host, operreason);
-	user->muted = true;
-	Instance->GlobalCulls.AddItem(user, quitreason.c_str(), operreason);
+	Instance->Logs->Log("USERS", DEBUG,"QuitUser: %s '%s'", user->nick, quitreason.c_str());
+	user->Write("ERROR :Closing link (%s@%s) [%s]", user->ident, user->host, *operreason ? operreason : quitreason.c_str());
+	user->quietquit = false;
+	user->quitmsg = quitreason;
+
+	if (!*operreason)
+		user->operquitmsg = quitreason;
+	else
+		user->operquitmsg = operreason;
+
+	Instance->GlobalCulls.AddItem(user);
 }
 
 /* adds or updates an entry in the whowas list */
@@ -866,184 +761,33 @@ void User::AddToWhoWas()
 	}
 }
 
-/* add a client connection to the sockets list */
-void User::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, int socketfamily, sockaddr* ip)
-{
-	/* NOTE: Calling this one parameter constructor for User automatically
-	 * allocates a new UUID and places it in the hash_map.
-	 */
-	User* New = NULL;
-	try
-	{
-		New = new User(Instance);
-	}
-	catch (...)
-	{
-		Instance->Log(DEFAULT,"*** WTF *** Duplicated UUID! -- Crack smoking monkies have been unleashed.");
-		Instance->WriteOpers("*** WARNING *** Duplicate UUID allocated!");
-		return;
-	}
-
-	int j = 0;
-
-	Instance->unregistered_count++;
-
-	char ipaddr[MAXBUF];
-#ifdef IPV6
-	if (socketfamily == AF_INET6)
-		inet_ntop(AF_INET6, &((const sockaddr_in6*)ip)->sin6_addr, ipaddr, sizeof(ipaddr));
-	else
-#endif
-	inet_ntop(AF_INET, &((const sockaddr_in*)ip)->sin_addr, ipaddr, sizeof(ipaddr));
-
-	(*(Instance->clientlist))[New->uuid] = New;
-	New->SetFd(socket);
-
-	/* The users default nick is their UUID */
-	strlcpy(New->nick, New->uuid, NICKMAX - 1);
-
-	New->server = Instance->FindServerNamePtr(Instance->Config->ServerName);
-	/* We don't need range checking here, we KNOW 'unknown\0' will fit into the ident field. */
-	strcpy(New->ident, "unknown");
-
-	New->registered = REG_NONE;
-	New->signon = Instance->Time() + Instance->Config->dns_timeout;
-	New->lastping = 1;
-
-	New->SetSockAddr(socketfamily, ipaddr, port);
-
-	/* Smarter than your average bear^H^H^H^Hset of strlcpys. */
-	for (const char* temp = New->GetIPString(); *temp && j < 64; temp++, j++)
-		New->dhost[j] = New->host[j] = *temp;
-	New->dhost[j] = New->host[j] = 0;
-
-	Instance->AddLocalClone(New);
-	Instance->AddGlobalClone(New);
-
-	/*
-	 * First class check. We do this again in FullConnect after DNS is done, and NICK/USER is recieved.
-	 * See my note down there for why this is required. DO NOT REMOVE. :) -- w00t
-	 */
-	ConnectClass* i = New->GetClass();
-
-	if (!i)
-	{
-		User::QuitUser(Instance, New, "Access denied by configuration");
-		return;
-	}
-
-	/*
-	 * Check connect class settings and initialise settings into User.
-	 * This will be done again after DNS resolution. -- w00t
-	 */
-	New->CheckClass();
-
-	Instance->local_users.push_back(New);
-
-	if ((Instance->local_users.size() > Instance->Config->SoftLimit) || (Instance->local_users.size() >= MAXCLIENTS))
-	{
-		Instance->WriteOpers("*** Warning: softlimit value has been reached: %d clients", Instance->Config->SoftLimit);
-		User::QuitUser(Instance, New,"No more connections allowed");
-		return;
-	}
-
-	/*
-	 * XXX -
-	 * this is done as a safety check to keep the file descriptors within range of fd_ref_table.
-	 * its a pretty big but for the moment valid assumption:
-	 * file descriptors are handed out starting at 0, and are recycled as theyre freed.
-	 * therefore if there is ever an fd over 65535, 65536 clients must be connected to the
-	 * irc server at once (or the irc server otherwise initiating this many connections, files etc)
-	 * which for the time being is a physical impossibility (even the largest networks dont have more
-	 * than about 10,000 users on ONE server!)
-	 */
-#ifndef WINDOWS
-	if ((unsigned int)socket >= MAX_DESCRIPTORS)
-	{
-		User::QuitUser(Instance, New, "Server is full");
-		return;
-	}
-#endif
-
-	New->exempt = (Instance->XLines->matches_exception(New) != NULL);
-	if (!New->exempt)
-	{
-		ZLine* r = Instance->XLines->matches_zline(ipaddr);
-		if (r)
-		{
-			char reason[MAXBUF];
-			if (*Instance->Config->MoronBanner)
-				New->WriteServ("NOTICE %s :*** %s", New->nick, Instance->Config->MoronBanner);
-			snprintf(reason,MAXBUF,"Z-Lined: %s",r->reason);
-			User::QuitUser(Instance, New, reason);
-			return;
-		}
-	}
-
-        if (socket > -1)
-        {
-                if (!Instance->SE->AddFd(New))
-                {
-			User::QuitUser(Instance, New, "Internal error handling connection");
-                }
-        }
-
-	/* NOTE: even if dns lookups are *off*, we still need to display this.
-	 * BOPM and other stuff requires it.
-	 */
-	New->WriteServ("NOTICE Auth :*** Looking up your hostname...");
-}
-
-unsigned long User::GlobalCloneCount()
-{
-	clonemap::iterator x = ServerInstance->global_clones.find(this->GetIPString());
-	if (x != ServerInstance->global_clones.end())
-		return x->second;
-	else
-		return 0;
-}
-
-unsigned long User::LocalCloneCount()
-{
-	clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString());
-	if (x != ServerInstance->local_clones.end())
-		return x->second;
-	else
-		return 0;
-}
-
 /*
  * Check class restrictions
  */
-void User::CheckClass(const std::string &explicit_class)
+void User::CheckClass()
 {
-	ConnectClass* a = this->GetClass(explicit_class);
+	ConnectClass* a = this->MyClass;
 
 	if ((!a) || (a->GetType() == CC_DENY))
 	{
 		User::QuitUser(ServerInstance, this, "Unauthorised connection");
 		return;
 	}
-	else if ((a->GetMaxLocal()) && (this->LocalCloneCount() > a->GetMaxLocal()))
+	else if ((a->GetMaxLocal()) && (ServerInstance->Users->LocalCloneCount(this) > a->GetMaxLocal()))
 	{
 		User::QuitUser(ServerInstance, this, "No more connections allowed from your host via this connect class (local)");
-		ServerInstance->WriteOpers("*** WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString());
+		ServerInstance->SNO->WriteToSnoMask('A', "WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString());
 		return;
 	}
-	else if ((a->GetMaxGlobal()) && (this->GlobalCloneCount() > a->GetMaxGlobal()))
+	else if ((a->GetMaxGlobal()) && (ServerInstance->Users->GlobalCloneCount(this) > a->GetMaxGlobal()))
 	{
 		User::QuitUser(ServerInstance, this, "No more connections allowed from your host via this connect class (global)");
-		ServerInstance->WriteOpers("*** WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString());
+		ServerInstance->SNO->WriteToSnoMask('A', "WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString());
 		return;
 	}
 
-	this->pingmax = a->GetPingTime();
 	this->nping = ServerInstance->Time() + a->GetPingTime() + ServerInstance->Config->dns_timeout;
 	this->timeout = ServerInstance->Time() + a->GetRegTimeout();
-	this->flood = a->GetFlood();
-	this->threshold = a->GetThreshold();
-	this->sendqmax = a->GetSendqMax();
-	this->recvqmax = a->GetRecvqMax();
 	this->MaxChans = a->GetMaxChans();
 }
 
@@ -1058,42 +802,32 @@ void User::FullConnect()
 	 * may put the user into a totally seperate class with different restrictions! so we *must* check again.
 	 * Don't remove this! -- w00t
 	 */
-	this->CheckClass();
+	this->SetClass();
 	
 	/* Check the password, if one is required by the user's connect class.
 	 * This CANNOT be in CheckClass(), because that is called prior to PASS as well!
 	 */
-	if ((!this->GetClass()->GetPass().empty()) && (!this->haspassed))
+	if (this->MyClass && !this->MyClass->GetPass().empty() && !this->haspassed)
 	{
 		User::QuitUser(ServerInstance, this, "Invalid password");
 		return;
 	}
-	
+
 	if (!this->exempt)
 	{
-		GLine* r = ServerInstance->XLines->matches_gline(this);
+		GLine *r = (GLine *)ServerInstance->XLines->MatchesLine("G", this);
 
 		if (r)
 		{
-			this->muted = true;
-			char reason[MAXBUF];
-			if (*ServerInstance->Config->MoronBanner)
-				this->WriteServ("NOTICE %s :*** %s", this->nick, ServerInstance->Config->MoronBanner);
-			snprintf(reason,MAXBUF,"G-Lined: %s",r->reason);
-			User::QuitUser(ServerInstance, this, reason);
+			r->Apply(this);
 			return;
 		}
 
-		KLine* n = ServerInstance->XLines->matches_kline(this);
+		KLine *n = (KLine *)ServerInstance->XLines->MatchesLine("K", this);
 
 		if (n)
 		{
-			this->muted = true;
-			char reason[MAXBUF];
-			if (*ServerInstance->Config->MoronBanner)
-				this->WriteServ("NOTICE %s :*** %s", this, ServerInstance->Config->MoronBanner);
-			snprintf(reason,MAXBUF,"K-Lined: %s",n->reason);
-			User::QuitUser(ServerInstance, this, reason);
+			n->Apply(this);
 			return;
 		}
 	}
@@ -1112,8 +846,8 @@ void User::FullConnect()
 	this->ShowMOTD();
 
 	/* Now registered */
-	if (ServerInstance->unregistered_count)
-		ServerInstance->unregistered_count--;
+	if (ServerInstance->Users->unregistered_count)
+		ServerInstance->Users->unregistered_count--;
 
 	/* Trigger LUSERS output, give modules a chance too */
 	int MOD_RESULT = 0;
@@ -1122,8 +856,8 @@ void User::FullConnect()
 		ServerInstance->CallCommandHandler("LUSERS", NULL, 0, this);
 
 	/*
-	 * fix 3 by brain, move registered = 7 below these so that spurious modes and host
-	 * changes dont go out onto the network and produce 'fake direction'.
+	 * We don't set REG_ALL until triggering OnUserConnect, so some module events don't spew out stuff
+	 * for a user that doesn't exist yet.
 	 */
 	FOREACH_MOD(I_OnUserConnect,OnUserConnect(this));
 
@@ -1132,6 +866,8 @@ void User::FullConnect()
 	FOREACH_MOD(I_OnPostConnect,OnPostConnect(this));
 
 	ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d: %s!%s@%s [%s] [%s]", this->GetPort(), this->nick, this->ident, this->host, this->GetIPString(), this->fullname);
+	ServerInstance->Logs->Log("BANCACHE", DEBUG, "BanCache: Adding NEGATIVE hit for %s", this->GetIPString());
+	ServerInstance->BanCache->AddHit(this->GetIPString(), "", "");
 }
 
 /** User::UpdateNick()
@@ -1140,28 +876,19 @@ void User::FullConnect()
  */
 User* User::UpdateNickHash(const char* New)
 {
-	try
-	{
-		//user_hash::iterator newnick;
-		user_hash::iterator oldnick = ServerInstance->clientlist->find(this->nick);
+	//user_hash::iterator newnick;
+	user_hash::iterator oldnick = ServerInstance->Users->clientlist->find(this->nick);
 
-		if (!strcasecmp(this->nick,New))
-			return oldnick->second;
+	if (!strcasecmp(this->nick,New))
+		return oldnick->second;
 
-		if (oldnick == ServerInstance->clientlist->end())
-			return NULL; /* doesnt exist */
+	if (oldnick == ServerInstance->Users->clientlist->end())
+		return NULL; /* doesnt exist */
 
-		User* olduser = oldnick->second;
-		(*(ServerInstance->clientlist))[New] = olduser;
-		ServerInstance->clientlist->erase(oldnick);
-		return olduser;
-	}
-
-	catch (...)
-	{
-		ServerInstance->Log(DEBUG,"Exception in User::UpdateNickHash()");
-		return NULL;
-	}
+	User* olduser = oldnick->second;
+	(*(ServerInstance->Users->clientlist))[New] = olduser;
+	ServerInstance->Users->clientlist->erase(oldnick);
+	return olduser;
 }
 
 void User::InvalidateCache()
@@ -1180,7 +907,13 @@ void User::InvalidateCache()
 
 bool User::ForceNickChange(const char* newnick)
 {
-	try
+	/*
+	 * XXX this makes no sense..
+	 * why do we do nothing for change on users not REG_ALL?
+	 * why do we trigger events twice for everyone previously (and just them now)
+	 * i think the first if () needs removing totally, or? -- w00t
+	 */
+	if (this->registered != REG_ALL)
 	{
 		int MOD_RESULT = 0;
 
@@ -1194,36 +927,33 @@ bool User::ForceNickChange(const char* newnick)
 			return false;
 		}
 
-		if (ServerInstance->XLines->matches_qline(newnick))
+		if (ServerInstance->XLines->MatchesLine("Q",newnick))
 		{
 			ServerInstance->stats->statsCollisions++;
 			return false;
 		}
-
-		if (this->registered == REG_ALL)
+	}
+	else
+	{
+		std::deque<classbase*> dummy;
+		Command* nickhandler = ServerInstance->Parser->GetHandler("NICK");
+		if (nickhandler) // wtfbbq, when would this not be here
 		{
-			std::deque<classbase*> dummy;
-			Command* nickhandler = ServerInstance->Parser->GetHandler("NICK");
-			if (nickhandler)
-			{
-				nickhandler->HandleInternal(1, dummy);
-				bool result = (ServerInstance->Parser->CallHandler("NICK", &newnick, 1, this) == CMD_SUCCESS);
-				nickhandler->HandleInternal(0, dummy);
-				return result;
-			}
+			nickhandler->HandleInternal(1, dummy);
+			bool result = (ServerInstance->Parser->CallHandler("NICK", &newnick, 1, this) == CMD_SUCCESS);
+			nickhandler->HandleInternal(0, dummy);
+			return result;
 		}
-		return false;
 	}
 
-	catch (...)
-	{
-		ServerInstance->Log(DEBUG,"Exception in User::ForceNickChange()");
-		return false;
-	}
+	// Unreachable.
+	return false;
 }
 
-void User::SetSockAddr(int protocol_family, const char* ip, int port)
+void User::SetSockAddr(int protocol_family, const char* sip, int port)
 {
+	this->cachedip = "";
+
 	switch (protocol_family)
 	{
 #ifdef SUPPORT_IP6LINKS
@@ -1232,7 +962,7 @@ void User::SetSockAddr(int protocol_family, const char* ip, int port)
 			sockaddr_in6* sin = new sockaddr_in6;
 			sin->sin6_family = AF_INET6;
 			sin->sin6_port = port;
-			inet_pton(AF_INET6, ip, &sin->sin6_addr);
+			inet_pton(AF_INET6, sip, &sin->sin6_addr);
 			this->ip = (sockaddr*)sin;
 		}
 		break;
@@ -1242,12 +972,12 @@ void User::SetSockAddr(int protocol_family, const char* ip, int port)
 			sockaddr_in* sin = new sockaddr_in;
 			sin->sin_family = AF_INET;
 			sin->sin_port = port;
-			inet_pton(AF_INET, ip, &sin->sin_addr);
+			inet_pton(AF_INET, sip, &sin->sin_addr);
 			this->ip = (sockaddr*)sin;
 		}
 		break;
 		default:
-			ServerInstance->Log(DEBUG,"Ut oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick);
+			ServerInstance->Logs->Log("USERS",DEBUG,"Uh oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick);
 		break;
 	}
 }
@@ -1288,6 +1018,10 @@ int User::GetProtocolFamily()
 	return sin->sin_family;
 }
 
+/*
+ * XXX the duplication here is horrid..
+ * do we really need two methods doing essentially the same thing?
+ */
 const char* User::GetIPString()
 {
 	static char buf[1024];
@@ -1295,46 +1029,8 @@ const char* User::GetIPString()
 	if (this->ip == NULL)
 		return "";
 
-	switch (this->GetProtocolFamily())
-	{
-#ifdef SUPPORT_IP6LINKS
-		case AF_INET6:
-		{
-			static char temp[1024];
-
-			sockaddr_in6* sin = (sockaddr_in6*)this->ip;
-			inet_ntop(sin->sin6_family, &sin->sin6_addr, buf, sizeof(buf));
-			/* IP addresses starting with a : on irc are a Bad Thing (tm) */
-			if (*buf == ':')
-			{
-				strlcpy(&temp[1], buf, sizeof(temp) - 1);
-				*temp = '0';
-				return temp;
-			}
-			return buf;
-		}
-		break;
-#endif
-		case AF_INET:
-		{
-			sockaddr_in* sin = (sockaddr_in*)this->ip;
-			inet_ntop(sin->sin_family, &sin->sin_addr, buf, sizeof(buf));
-			return buf;
-		}
-		break;
-		default:
-		break;
-	}
-	return "";
-}
-
-const char* User::GetIPString(char* buf)
-{
-	if (this->ip == NULL)
-	{
-		*buf = 0;
-		return buf;
-	}
+	if (!this->cachedip.empty())
+		return this->cachedip.c_str();
 
 	switch (this->GetProtocolFamily())
 	{
@@ -1350,8 +1046,11 @@ const char* User::GetIPString(char* buf)
 			{
 				strlcpy(&temp[1], buf, sizeof(temp) - 1);
 				*temp = '0';
-				strlcpy(buf, temp, sizeof(temp));
+				this->cachedip = temp;
+				return temp;
 			}
+			
+			this->cachedip = buf;
 			return buf;
 		}
 		break;
@@ -1360,13 +1059,15 @@ const char* User::GetIPString(char* buf)
 		{
 			sockaddr_in* sin = (sockaddr_in*)this->ip;
 			inet_ntop(sin->sin_family, &sin->sin_addr, buf, sizeof(buf));
+			this->cachedip = buf;
 			return buf;
 		}
 		break;
-
 		default:
 		break;
 	}
+	
+	// Unreachable, probably
 	return "";
 }
 
@@ -1383,31 +1084,27 @@ void User::Write(std::string text)
 
 	try
 	{
-		/* ServerInstance->Log(DEBUG,"C[%d] O %s", this->GetFd(), text.c_str());
-		 * WARNING: The above debug line is VERY loud, do NOT
-		 * enable it till we have a good way of filtering it
-		 * out of the logs (e.g. 1.2 would be good).
-		 */
+		ServerInstance->Logs->Log("USEROUTPUT", DEBUG,"C[%d] O %s", this->GetFd(), text.c_str());
 		text.append("\r\n");
 	}
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::Write() std::string::append");
+		ServerInstance->Logs->Log("USEROUTPUT", DEBUG,"Exception in User::Write() std::string::append");
 		return;
 	}
 
 	if (ServerInstance->Config->GetIOHook(this->GetPort()))
 	{
+		/* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to
+		 * implement their own buffering mechanisms
+		 */
 		try
 		{
-			/* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to
-			 * implement their own buffering mechanisms
-			 */
 			ServerInstance->Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, text.data(), text.length());
 		}
 		catch (CoreException& modexcept)
 		{
-			ServerInstance->Log(DEBUG, "%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+			ServerInstance->Logs->Log("USEROUTPUT", DEBUG, "%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
 		}
 	}
 	else
@@ -1456,6 +1153,32 @@ void User::WriteServ(const char* text, ...)
 }
 
 
+void User::WriteNumeric(unsigned int numeric, const char* text, ...)
+{
+	va_list argsPtr;
+	char textbuffer[MAXBUF];
+
+	va_start(argsPtr, text);
+	vsnprintf(textbuffer, MAXBUF, text, argsPtr);
+	va_end(argsPtr);
+
+	this->WriteNumeric(numeric, std::string(textbuffer));
+}
+
+void User::WriteNumeric(unsigned int numeric, const std::string &text)
+{
+	char textbuffer[MAXBUF];
+	int MOD_RESULT = 0;
+
+	FOREACH_RESULT(I_OnNumeric, OnNumeric(this, numeric, text));
+
+	if (MOD_RESULT)
+		return;
+
+	snprintf(textbuffer,MAXBUF,":%s %u %s %s",ServerInstance->Config->ServerName, numeric, this->nick, text.c_str());
+	this->Write(std::string(textbuffer));
+}
+
 void User::WriteFrom(User *user, const std::string &text)
 {
 	char tb[MAXBUF];
@@ -1518,47 +1241,39 @@ void User::WriteCommon(const char* text, ...)
 
 void User::WriteCommon(const std::string &text)
 {
-	try
-	{
-		bool sent_to_at_least_one = false;
-		char tb[MAXBUF];
+	bool sent_to_at_least_one = false;
+	char tb[MAXBUF];
 
-		if (this->registered != REG_ALL)
-			return;
+	if (this->registered != REG_ALL)
+		return;
 
-		uniq_id++;
+	uniq_id++;
 
-		/* We dont want to be doing this n times, just once */
-		snprintf(tb,MAXBUF,":%s %s",this->GetFullHost(),text.c_str());
-		std::string out = tb;
+	/* We dont want to be doing this n times, just once */
+	snprintf(tb,MAXBUF,":%s %s",this->GetFullHost(),text.c_str());
+	std::string out = tb;
 
-		for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++)
+	for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++)
+	{
+		CUList* ulist = v->first->GetUsers();
+		for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
 		{
-			CUList* ulist = v->first->GetUsers();
-			for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
+			if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id))
 			{
-				if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id))
-				{
-					already_sent[i->first->fd] = uniq_id;
-					i->first->Write(out);
-					sent_to_at_least_one = true;
-				}
+				already_sent[i->first->fd] = uniq_id;
+				i->first->Write(out);
+				sent_to_at_least_one = true;
 			}
 		}
-
-		/*
-		 * if the user was not in any channels, no users will receive the text. Make sure the user
-		 * receives their OWN message for WriteCommon
-		 */
-		if (!sent_to_at_least_one)
-		{
-			this->Write(std::string(tb));
-		}
 	}
 
-	catch (...)
+	/*
+	 * if the user was not in any channels, no users will receive the text. Make sure the user
+	 * receives their OWN message for WriteCommon
+	 */
+	if (!sent_to_at_least_one)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::WriteCommon()");
+		this->Write(std::string(tb));
 	}
 }
 
@@ -1648,7 +1363,7 @@ void User::WriteWallOps(const std::string &text)
 	std::string wallop("WALLOPS :");
 	wallop.append(text);
 
-	for (std::vector<User*>::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++)
+	for (std::vector<User*>::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++)
 	{
 		User* t = *i;
 		if (t->IsModeSet('w'))
@@ -1715,24 +1430,25 @@ bool User::ChangeName(const char* gecos)
 	return true;
 }
 
-bool User::ChangeDisplayedHost(const char* host)
+bool User::ChangeDisplayedHost(const char* shost)
 {
-	if (!strcmp(host, this->dhost))
+	if (!strcmp(shost, this->dhost))
 		return true;
 
 	if (IS_LOCAL(this))
 	{
 		int MOD_RESULT = 0;
-		FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(this,host));
+		FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(this,shost));
 		if (MOD_RESULT)
 			return false;
-		FOREACH_MOD(I_OnChangeHost,OnChangeHost(this,host));
+		FOREACH_MOD(I_OnChangeHost,OnChangeHost(this,shost));
 	}
+
 	if (this->ServerInstance->Config->CycleHosts)
 		this->WriteCommonExcept("QUIT :Changing hosts");
 
 	/* Fix by Om: User::dhost is 65 long, this was truncating some long hosts */
-	strlcpy(this->dhost,host,64);
+	strlcpy(this->dhost,shost,64);
 
 	this->InvalidateCache();
 
@@ -1761,7 +1477,7 @@ bool User::ChangeIdent(const char* newident)
 	if (this->ServerInstance->Config->CycleHosts)
 		this->WriteCommonExcept("%s","QUIT :Changing ident");
 
-	strlcpy(this->ident, newident, IDENTMAX+2);
+	strlcpy(this->ident, newident, IDENTMAX+1);
 
 	this->InvalidateCache();
 
@@ -1779,7 +1495,7 @@ bool User::ChangeIdent(const char* newident)
 	return true;
 }
 
-void User::SendAll(const char* command, char* text, ...)
+void User::SendAll(const char* command, const char* text, ...)
 {
 	char textbuffer[MAXBUF];
 	char formatbuffer[MAXBUF];
@@ -1792,7 +1508,7 @@ void User::SendAll(const char* command, char* text, ...)
 	snprintf(formatbuffer,MAXBUF,":%s %s $* :%s", this->GetFullHost(), command, textbuffer);
 	std::string fmt = formatbuffer;
 
-	for (std::vector<User*>::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++)
+	for (std::vector<User*>::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++)
 	{
 		(*i)->Write(fmt);
 	}
@@ -1801,27 +1517,21 @@ void User::SendAll(const char* command, char* text, ...)
 
 std::string User::ChannelList(User* source)
 {
-	try
+	std::string list;
+
+	for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
 	{
-		std::string list;
-		for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
+		/* If the target is the same as the sender, let them see all their channels.
+		 * If the channel is NOT private/secret OR the user shares a common channel
+		 * If the user is an oper, and the <options:operspywhois> option is set.
+		 */
+		if ((source == this) || (IS_OPER(source) && ServerInstance->Config->OperSpyWhois) || (((!i->first->IsModeSet('p')) && (!i->first->IsModeSet('s'))) || (i->first->HasUser(source))))
 		{
-			/* If the target is the same as the sender, let them see all their channels.
-			 * If the channel is NOT private/secret OR the user shares a common channel
-			 * If the user is an oper, and the <options:operspywhois> option is set.
-			 */
-			if ((source == this) || (IS_OPER(source) && ServerInstance->Config->OperSpyWhois) || (((!i->first->IsModeSet('p')) && (!i->first->IsModeSet('s'))) || (i->first->HasUser(source))))
-			{
-				list.append(i->first->GetPrefixChar(this)).append(i->first->name).append(" ");
-			}
+			list.append(i->first->GetPrefixChar(this)).append(i->first->name).append(" ");
 		}
-		return list;
-	}
-	catch (...)
-	{
-		ServerInstance->Log(DEBUG,"Exception in User::ChannelList()");
-		return "";
 	}
+
+	return list;
 }
 
 void User::SplitChanList(User* dest, const std::string &cl)
@@ -1830,42 +1540,34 @@ void User::SplitChanList(User* dest, const std::string &cl)
 	std::ostringstream prefix;
 	std::string::size_type start, pos, length;
 
-	try
+	prefix << this->nick << " " << dest->nick << " :";
+	line = prefix.str();
+	int namelen = strlen(ServerInstance->Config->ServerName) + 6;
+
+	for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1)
 	{
-		prefix << this->nick << " " << dest->nick << " :";
-		line = prefix.str();
-		int namelen = strlen(ServerInstance->Config->ServerName) + 6;
+		length = (pos == std::string::npos) ? cl.length() : pos;
 
-		for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1)
+		if (line.length() + namelen + length - start > 510)
 		{
-			length = (pos == std::string::npos) ? cl.length() : pos;
-
-			if (line.length() + namelen + length - start > 510)
-			{
-				ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str());
-				line = prefix.str();
-			}
-
-			if(pos == std::string::npos)
-			{
-				line.append(cl.substr(start, length - start));
-				break;
-			}
-			else
-			{
-				line.append(cl.substr(start, length - start + 1));
-			}
+			ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str());
+			line = prefix.str();
 		}
 
-		if (line.length())
+		if(pos == std::string::npos)
 		{
-			ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str());
+			line.append(cl.substr(start, length - start));
+			break;
+		}
+		else
+		{
+			line.append(cl.substr(start, length - start + 1));
 		}
 	}
 
-	catch (...)
+	if (line.length())
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::SplitChanList()");
+		ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str());
 	}
 }
 
@@ -1874,40 +1576,94 @@ unsigned int User::GetMaxChans()
 	return this->MaxChans;
 }
 
-/* looks up a users password for their connection class (<ALLOW>/<DENY> tags)
+
+/*
+ * Sets a user's connection class.
+ * If the class name is provided, it will be used. Otherwise, the class will be guessed using host/ip/ident/etc.
  * NOTE: If the <ALLOW> or <DENY> tag specifies an ip, and this user resolves,
  * then their ip will be taken as 'priority' anyway, so for example,
  * <connect allow="127.0.0.1"> will match joe!bloggs@localhost
  */
-ConnectClass* User::GetClass(const std::string &explicit_name)
+ConnectClass* User::SetClass(const std::string &explicit_name)
 {
+	ConnectClass *found = NULL;
+
+	if (!IS_LOCAL(this))
+		return NULL;
+
 	if (!explicit_name.empty())
 	{
 		for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++)
 		{
-			if (explicit_name == i->GetName())
-				return &(*i);
+			ConnectClass* c = *i;
+
+			if (explicit_name == c->GetName() && !c->GetDisabled())
+			{
+				found = c;
+			}
 		}
 	}
 	else
 	{
 		for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++)
 		{
-			if (((match(this->GetIPString(),i->GetHost().c_str(),true)) || (match(this->host,i->GetHost().c_str()))))
+			ConnectClass* c = *i;
+
+			if (((match(this->GetIPString(),c->GetHost().c_str(),true)) || (match(this->host,c->GetHost().c_str()))))
 			{
-				if (i->GetPort())
+				if (c->GetPort())
 				{
-					if (this->GetPort() == i->GetPort())
-						return &(*i);
+					if (this->GetPort() == c->GetPort() && !c->GetDisabled())
+					{
+						found = c;
+					}
 					else
 						continue;
 				}
 				else
-					return &(*i);
+				{
+					if (!c->GetDisabled())
+						found = c;
+				}
 			}
 		}
 	}
-	return NULL;
+
+	/* ensure we don't fuck things up refcount wise, only remove them from a class if we find a new one :P */
+	if (found)
+	{
+		/* deny change if change will take class over the limit */
+		if (found->limit && (found->RefCount + 1 >= found->limit))
+		{
+			ServerInstance->Logs->Log("USERS", DEBUG, "OOPS: Connect class limit (%u) hit, denying", found->limit);
+			return this->MyClass;
+		}
+
+		/* should always be valid, but just in case .. */
+		if (this->MyClass)
+		{
+			if (found == this->MyClass) // no point changing this shit :P
+				return this->MyClass;
+			this->MyClass->RefCount--;
+			ServerInstance->Logs->Log("USERS", DEBUG, "Untying user from connect class -- refcount: %u", this->MyClass->RefCount);
+		}
+
+		this->MyClass = found;
+		this->MyClass->RefCount++;
+		ServerInstance->Logs->Log("USERS", DEBUG, "User tied to new class -- connect refcount now: %u", this->MyClass->RefCount);
+	}
+
+	return this->MyClass;
+}
+
+/* looks up a users password for their connection class (<ALLOW>/<DENY> tags)
+ * NOTE: If the <ALLOW> or <DENY> tag specifies an ip, and this user resolves,
+ * then their ip will be taken as 'priority' anyway, so for example,
+ * <connect allow="127.0.0.1"> will match joe!bloggs@localhost
+ */
+ConnectClass* User::GetClass()
+{
+	return this->MyClass;
 }
 
 void User::PurgeEmptyChannels()
@@ -1927,7 +1683,7 @@ void User::PurgeEmptyChannels()
 			}
 			catch (...)
 			{
-				ServerInstance->Log(DEBUG,"Exception in User::PurgeEmptyChannels to_delete.push_back()");
+				ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::PurgeEmptyChannels to_delete.push_back()");
 			}
 		}
 	}
@@ -1939,7 +1695,7 @@ void User::PurgeEmptyChannels()
 		if (i2 != ServerInstance->chanlist->end())
 		{
 			FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second));
-			DELETE(i2->second);
+			delete i2->second;
 			ServerInstance->chanlist->erase(i2);
 			this->chans.erase(*n);
 		}
@@ -1981,6 +1737,9 @@ void User::ShowRULES()
 
 void User::HandleEvent(EventType et, int errornum)
 {
+	if (this->quitting) // drop everything, user is due to be quit
+		return;
+
 	/* WARNING: May delete this user! */
 	int thisfd = this->GetFd();
 
@@ -2002,7 +1761,7 @@ void User::HandleEvent(EventType et, int errornum)
 	}
 	catch (...)
 	{
-		ServerInstance->Log(DEBUG,"Exception in User::HandleEvent intercepted");
+		ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::HandleEvent intercepted");
 	}
 
 	/* If the user has raised an error whilst being processed, quit them now we're safe to */
@@ -2017,15 +1776,22 @@ void User::HandleEvent(EventType et, int errornum)
 
 void User::SetOperQuit(const std::string &oquit)
 {
-	if (operquit)
-		return;
-
-	operquit = strdup(oquit.c_str());
+	operquitmsg = oquit;
 }
 
 const char* User::GetOperQuit()
 {
-	return operquit ? operquit : "";
+	return operquitmsg.c_str();
+}
+
+void User::IncreasePenalty(int increase)
+{
+	this->Penalty += increase;
+}
+
+void User::DecreasePenalty(int decrease)
+{
+	this->Penalty -= decrease;
 }
 
 VisData::VisData()