X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fxline.cpp;h=7979a1d82278cf4cd2871fdc142e64f61c4c4cb4;hb=ae8341627017a0a1b1e1033c6239b4ebb16e7219;hp=ffe38c94da13bdf36ad49600af1571bbfe6a1d04;hpb=7141595fda12cc3ec24ecc38543f20b515825f22;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/xline.cpp b/src/xline.cpp
index ffe38c94d..7979a1d82 100644
--- a/src/xline.cpp
+++ b/src/xline.cpp
@@ -2,103 +2,48 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
- *                       E-mail:
- *                <brain@chatspike.net>
- *           	  <Craig@chatspike.net>
- *     
- * Written by Craig Edwards, Craig McLure, and others.
+ *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
+ *
  * This program is free but copyrighted software; see
  *            the file COPYING for details.
  *
  * ---------------------------------------------------
  */
 
-using namespace std;
+/* $Core: libIRCDxline */
 
-#include "inspircd_config.h"
 #include "inspircd.h"
-#include "inspircd_io.h"
-#include "inspircd_util.h"
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/errno.h>
-#include <time.h>
-#include <string>
-#ifdef GCC3
-#include <ext/hash_map>
-#else
-#include <hash_map>
-#endif
-#include <map>
-#include <sstream>
-#include <vector>
-#include <deque>
-#include "users.h"
-#include "ctables.h"
-#include "globals.h"
-#include "modules.h"
-#include "dynamic.h"
 #include "wildcard.h"
-#include "message.h"
-#include "commands.h"
 #include "xline.h"
-#include "inspstring.h"
-#include "helperfuncs.h"
-#include "hashcomp.h"
-
-extern int MODCOUNT;
-extern std::vector<Module*> modules;
-extern std::vector<ircd_module*> factory;
-
-extern int LogLevel;
-extern char ServerName[MAXBUF];
-extern char Network[MAXBUF];
-extern char ServerDesc[MAXBUF];
-extern char AdminName[MAXBUF];
-extern char AdminEmail[MAXBUF];
-extern char AdminNick[MAXBUF];
-extern char diepass[MAXBUF];
-extern char restartpass[MAXBUF];
-extern char motd[MAXBUF];
-extern char rules[MAXBUF];
-extern char list[MAXBUF];
-extern char PrefixQuit[MAXBUF];
-extern char DieValue[MAXBUF];
-
-extern int debugging;
-extern int WHOWAS_STALE;
-extern int WHOWAS_MAX;
-extern int DieDelay;
-extern time_t startup_time;
-extern int NetBufferSize;
-extern time_t nb_start;
-
-extern std::vector<std::string> module_names;
-
-extern int boundPortCount;
-extern int portCount;
-
-extern int ports[MAXSOCKS];
-
-extern std::stringstream config_f;
-
-extern FILE *log_file;
-
-typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
-typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
-typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache;
-typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash;
-typedef std::deque<command_t> command_table;
-
-
-extern user_hash clientlist;
-extern chan_hash chanlist;
-extern whowas_hash whowas;
-extern command_table cmdlist;
-extern file_cache MOTD;
-extern file_cache RULES;
-extern address_cache IP;
+
+/*
+ * This is now version 3 of the XLine subsystem, let's see if we can get it as nice and 
+ * efficient as we can this time so we can close this file and never ever touch it again ..
+ *
+ * Background:
+ *  Version 1 stored all line types in one list (one for g, one for z, etc). This was fine,
+ *  but both version 1 and 2 suck at applying lines efficiently. That is, every time a new line
+ *  was added, it iterated every existing line for every existing user. Ow. Expiry was also
+ *  expensive, as the lists were NOT sorted.
+ *
+ *  Version 2 moved permanent lines into a seperate list from non-permanent to help optimize
+ *  matching speed, but matched in the same way.
+ *  Expiry was also sped up by sorting the list by expiry (meaning just remove the items at the
+ *  head of the list that are outdated.)
+ *
+ * This was fine and good, but it looked less than ideal in code, and matching was still slower
+ * than it could have been, something which we address here.
+ *
+ * VERSION 3:
+ *  All lines are (as in v1) stored together -- no seperation of perm and non-perm. Expiry will
+ *  still use a sorted list, and we'll just ignore anything permanent.
+ *
+ *  Application will be by a list of lines 'pending' application, meaning only the newly added lines
+ *  will be gone over. Much faster.
+ *
+ * More of course is to come.
+ */
 
 /* Version two, now with optimized expiry!
  *
@@ -106,10 +51,10 @@ extern address_cache IP;
  * very efficient. I have improved the efficiency of the algorithm in two ways:
  *
  * (1) There are now two lists of items for each linetype. One list holds temporary
- *     items, and the other list holds permenant items (ones which will expire).
- *     Items which are on the permenant list are NEVER checked at all by the
+ *     items, and the other list holds permanent items (ones which will expire).
+ *     Items which are on the permanent list are NEVER checked at all by the
  *     expire_lines() function.
- * (2) The temporary xline lists are always kept in strict numerical order, keyed by 
+ * (2) The temporary xline lists are always kept in strict numerical order, keyed by
  *     current time + duration. This means that the line which is due to expire the
  *     soonest is always pointed at by vector::begin(), so a simple while loop can
  *     very efficiently, very quickly and above all SAFELY pick off the first few
@@ -118,688 +63,697 @@ extern address_cache IP;
  *     -- Brain
  */
 
+bool InitXLine(ServerConfig* conf, const char* tag)
+{
+	return true;
+}
 
+bool DoneZLine(ServerConfig* conf, const char* tag)
+{
+	// XXX we should really only call this once - after we've finished processing configuration all together
+	conf->GetInstance()->XLines->ApplyLines();
+	return true;
+}
 
-extern time_t TIME;
+bool DoneQLine(ServerConfig* conf, const char* tag)
+{
+	// XXX we should really only call this once - after we've finished processing configuration all together
+	conf->GetInstance()->XLines->ApplyLines();
+	return true;
+}
 
-/* Lists for temporary lines with an expiry time */
+bool DoneKLine(ServerConfig* conf, const char* tag)
+{
+	// XXX we should really only call this once - after we've finished processing configuration all together
+	conf->GetInstance()->XLines->ApplyLines();
+	return true;
+}
+
+bool DoneELine(ServerConfig* conf, const char* tag)
+{
+	// XXX we should really only call this once - after we've finished processing configuration all together
+	conf->GetInstance()->XLines->ApplyLines();
+	return true;
+}
 
-std::vector<KLine> klines;
-std::vector<GLine> glines;
-std::vector<ZLine> zlines;
-std::vector<QLine> qlines;
-std::vector<ELine> elines;
+bool DoZLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+{
+	const char* reason = values[0].GetString();
+	const char* ipmask = values[1].GetString();
 
-/* Seperate lists for perm XLines that isnt checked by expiry functions */
+	conf->GetInstance()->XLines->AddZLine(0,"<Config>",reason,ipmask);
+	return true;
+}
 
-std::vector<KLine> pklines;
-std::vector<GLine> pglines;
-std::vector<ZLine> pzlines;
-std::vector<QLine> pqlines;
-std::vector<ELine> pelines;
+bool DoQLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+{
+	const char* reason = values[0].GetString();
+	const char* nick = values[1].GetString();
 
+	conf->GetInstance()->XLines->AddQLine(0,"<Config>",reason,nick);
+	return true;
+}
 
-bool GSortComparison ( const GLine one, const GLine two );
-bool ZSortComparison ( const ZLine one, const ZLine two );
-bool ESortComparison ( const ELine one, const ELine two );
-bool QSortComparison ( const QLine one, const QLine two );
-bool KSortComparison ( const KLine one, const KLine two );
+bool DoKLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+{
+	const char* reason = values[0].GetString();
+	const char* host = values[1].GetString();
 
-// Reads the default bans from the config file.
-// only a very small number of bans are defined
-// this way these days, such as qlines against 
-// services nicks, etc.
+	conf->GetInstance()->XLines->AddKLine(0,"<Config>",reason,host);
+	return true;
+}
 
-void read_xline_defaults()
+bool DoELine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
 {
-	char ipmask[MAXBUF];
-	char nick[MAXBUF];
-	char host[MAXBUF];
-	char reason[MAXBUF];
+	const char* reason = values[0].GetString();
+	const char* host = values[1].GetString();
 
-	for (int i = 0; i < ConfValueEnum("badip",&config_f); i++)
-	{
-		ConfValue("badip","ipmask",i,ipmask,&config_f);
-		ConfValue("badip","reason",i,reason,&config_f);
-		add_zline(0,"<Config>",reason,ipmask);
-		log(DEBUG,"Read Z line (badip tag): ipmask=%s reason=%s",ipmask,reason);
-	}
-	
-	for (int i = 0; i < ConfValueEnum("badnick",&config_f); i++)
-	{
-		ConfValue("badnick","nick",i,nick,&config_f);
-		ConfValue("badnick","reason",i,reason,&config_f);
-		add_qline(0,"<Config>",reason,nick);
-		log(DEBUG,"Read Q line (badnick tag): nick=%s reason=%s",nick,reason);
-	}
-	
-	for (int i = 0; i < ConfValueEnum("badhost",&config_f); i++)
-	{
-		ConfValue("badhost","host",i,host,&config_f);
-		ConfValue("badhost","reason",i,reason,&config_f);
-		add_kline(0,"<Config>",reason,host);
-		log(DEBUG,"Read K line (badhost tag): host=%s reason=%s",host,reason);
-	}
-	for (int i = 0; i < ConfValueEnum("exception",&config_f); i++)
+	conf->GetInstance()->XLines->AddELine(0,"<Config>",reason,host);
+	return true;
+}
+
+bool XLine::Matches(User *u)
+{
+	return false;
+}
+
+//XXX perhaps move into xlinemanager
+void CheckELines(InspIRCd *ServerInstance, std::vector<ELine *> &ELines)
+{
+	for (std::vector<User*>::const_iterator u2 = ServerInstance->local_users.begin(); u2 != ServerInstance->local_users.end(); u2++)
 	{
-		ConfValue("exception","host",i,host,&config_f);
-		ConfValue("exception","reason",i,reason,&config_f);
-		add_eline(0,"<Config>",reason,host);
-		log(DEBUG,"Read E line (exception tag): host=%s reason=%s",host,reason);
+		User* u = (User*)(*u2);
+
+		for (std::vector<ELine *>::iterator i = ELines.begin(); i != ELines.end(); i++)
+		{
+			ELine *e = (*i);
+
+			u->exempt = e->Matches(u);
+		}
 	}
 }
 
-// adds a g:line
 
-void add_gline(long duration, const char* source,const char* reason,const char* hostmask)
-{
-	del_gline(hostmask);
-	GLine item;
-	item.duration = duration;
-	strlcpy(item.hostmask,hostmask,199);
-	strlcpy(item.reason,reason,MAXBUF);
-	strlcpy(item.source,source,255);
-	item.n_matches = 0;
-	item.set_time = TIME;
-	if (duration)
+IdentHostPair XLineManager::IdentSplit(const std::string &ident_and_host)
+{
+	IdentHostPair n = std::make_pair<std::string,std::string>("*","*");
+	std::string::size_type x = ident_and_host.find('@');
+	if (x != std::string::npos)
 	{
-		glines.push_back(item);
-		sort(glines.begin(), glines.end(),GSortComparison);
+		n.second = ident_and_host.substr(x + 1,ident_and_host.length());
+		n.first = ident_and_host.substr(0, x);
+		if (!n.first.length())
+			n.first.assign("*");
+		if (!n.second.length())
+			n.second.assign("*");
 	}
 	else
 	{
-		pglines.push_back(item);
+		n.second = ident_and_host;
 	}
+
+	return n;
+}
+
+// adds a g:line
+
+bool XLineManager::AddGLine(long duration, const char* source,const char* reason,const char* hostmask)
+{
+	IdentHostPair ih = IdentSplit(hostmask);
+
+	if (DelGLine(hostmask, true))
+		return false;
+
+	GLine* item = new GLine(ServerInstance, ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());
+
+	glines.push_back(item);
+	sort(glines.begin(), glines.end(),XLineManager::XSortComparison);
+	pending_lines.push_back(item);
+
+	return true;
 }
 
 // adds an e:line (exception to bans)
 
-void add_eline(long duration, const char* source, const char* reason, const char* hostmask)
-{
-        del_eline(hostmask);
-        ELine item;
-        item.duration = duration;
-        strlcpy(item.hostmask,hostmask,199);
-        strlcpy(item.reason,reason,MAXBUF);
-        strlcpy(item.source,source,255);
-        item.n_matches = 0;
-        item.set_time = TIME;
-	if (duration)
-	{
-        	elines.push_back(item);
-		sort(elines.begin(), elines.end(),ESortComparison);
-	}
-	else
-	{
-		pelines.push_back(item);
-	}
+bool XLineManager::AddELine(long duration, const char* source, const char* reason, const char* hostmask)
+{
+	IdentHostPair ih = IdentSplit(hostmask);
+
+	if (DelELine(hostmask, true))
+		return false;
+
+	ELine* item = new ELine(ServerInstance, ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());
+
+	elines.push_back(item);
+	sort(elines.begin(), elines.end(),XLineManager::XSortComparison);
+
+	// XXX we really only need to check one line (the new one) - this is a bit wasteful!
+	CheckELines(ServerInstance, elines);
+
+	return true;
 }
 
 // adds a q:line
 
-void add_qline(long duration, const char* source, const char* reason, const char* nickname)
-{
-	del_qline(nickname);
-	QLine item;
-	item.duration = duration;
-	strlcpy(item.nick,nickname,63);
-	strlcpy(item.reason,reason,MAXBUF);
-	strlcpy(item.source,source,255);
-	item.n_matches = 0;
-	item.is_global = false;
-	item.set_time = TIME;
-	if (duration)
-	{
-		qlines.push_back(item);
-		sort(qlines.begin(), qlines.end(),QSortComparison);
-	}
-	else
-	{
-		pqlines.push_back(item);
-	}
+bool XLineManager::AddQLine(long duration, const char* source, const char* reason, const char* nickname)
+{
+	if (DelQLine(nickname, true))
+		return false;
+
+	QLine* item = new QLine(ServerInstance, ServerInstance->Time(), duration, source, reason, nickname);
+
+	qlines.push_back(item);
+	sort(qlines.begin(), qlines.end(),XLineManager::XSortComparison);
+	pending_lines.push_back(item);
+
+	return true;
 }
 
 // adds a z:line
 
-void add_zline(long duration, const char* source, const char* reason, const char* ipaddr)
+bool XLineManager::AddZLine(long duration, const char* source, const char* reason, const char* ipaddr)
 {
-	del_zline(ipaddr);
-	ZLine item;
-	item.duration = duration;
 	if (strchr(ipaddr,'@'))
 	{
 		while (*ipaddr != '@')
 			ipaddr++;
 		ipaddr++;
 	}
-	strlcpy(item.ipaddr,ipaddr,39);
-	strlcpy(item.reason,reason,MAXBUF);
-	strlcpy(item.source,source,255);
-	item.n_matches = 0;
-	item.is_global = false;
-	item.set_time = TIME;
-	if (duration)
-	{
-		zlines.push_back(item);
-		sort(zlines.begin(), zlines.end(),ZSortComparison);
-	}
-	else
-	{
-		pzlines.push_back(item);
-	}
-}
 
-// adds a k:line
+	if (DelZLine(ipaddr, true))
+		return false;
 
-void add_kline(long duration, const char* source, const char* reason, const char* hostmask)
-{
-	del_kline(hostmask);
-	KLine item;
-	item.duration = duration;
-	strlcpy(item.hostmask,hostmask,200);
-	strlcpy(item.reason,reason,MAXBUF);
-	strlcpy(item.source,source,255);
-	item.n_matches = 0;
-	item.set_time = TIME;
-	if (duration)
-	{
-		klines.push_back(item);
-		sort(klines.begin(), klines.end(),KSortComparison);
-	}
-	else
-	{
-		pklines.push_back(item);
-	}
+	ZLine* item = new ZLine(ServerInstance, ServerInstance->Time(), duration, source, reason, ipaddr);
+
+	zlines.push_back(item);
+	sort(zlines.begin(), zlines.end(),XLineManager::XSortComparison);
+	pending_lines.push_back(item);
+
+	return true;
 }
 
-// deletes a g:line, returns true if the line existed and was removed
+// adds a k:line
 
-bool del_gline(const char* hostmask)
+bool XLineManager::AddKLine(long duration, const char* source, const char* reason, const char* hostmask)
 {
-	for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
-	{
-		if (!strcasecmp(hostmask,i->hostmask))
-		{
-			glines.erase(i);
-			return true;
-		}
-	}
-	for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
-	{
-		if (!strcasecmp(hostmask,i->hostmask))
-		{
-			pglines.erase(i);
-			return true;
-		}
-	}
-	return false;
-}
+	IdentHostPair ih = IdentSplit(hostmask);
 
-// deletes a e:line, returns true if the line existed and was removed
+	if (DelKLine(hostmask, true))
+		return false;
 
-bool del_eline(const char* hostmask)
-{
-        for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
-        {
-                if (!strcasecmp(hostmask,i->hostmask))
-                {
-                        elines.erase(i);
-                        return true;
-                }
-        }
-	for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
-	{
-		if (!strcasecmp(hostmask,i->hostmask))
-		{
-			pelines.erase(i);
-			return true;
-		}
-	}
-        return false;
+	KLine* item = new KLine(ServerInstance, ServerInstance->Time(), duration, source, reason, ih.first.c_str(), ih.second.c_str());
+
+	klines.push_back(item);
+	sort(klines.begin(), klines.end(),XLineManager::XSortComparison);
+	pending_lines.push_back(item);
+
+	return true;
 }
 
-// deletes a q:line, returns true if the line existed and was removed
+// deletes a g:line, returns true if the line existed and was removed
 
-bool del_qline(const char* nickname)
+bool XLineManager::DelGLine(const char* hostmask, bool simulate)
 {
-	for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
-	{
-		if (!strcasecmp(nickname,i->nick))
-		{
-			qlines.erase(i);
-			return true;
-		}
-	}
-	for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
+	IdentHostPair ih = IdentSplit(hostmask);
+	for (std::vector<GLine*>::iterator i = glines.begin(); i != glines.end(); i++)
 	{
-		if (!strcasecmp(nickname,i->nick))
+		if (!strcasecmp(ih.first.c_str(),(*i)->identmask) && !strcasecmp(ih.second.c_str(),(*i)->hostmask))
 		{
-			pqlines.erase(i);
+			if (!simulate)
+			{
+				delete *i;
+				glines.erase(i);
+			}
 			return true;
 		}
 	}
+
 	return false;
 }
 
-bool qline_make_global(const char* nickname)
+// deletes a e:line, returns true if the line existed and was removed
+
+bool XLineManager::DelELine(const char* hostmask, bool simulate)
 {
-	for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
+	IdentHostPair ih = IdentSplit(hostmask);
+	for (std::vector<ELine*>::iterator i = elines.begin(); i != elines.end(); i++)
 	{
-		if (!strcasecmp(nickname,i->nick))
+		if (!strcasecmp(ih.first.c_str(),(*i)->identmask) && !strcasecmp(ih.second.c_str(),(*i)->hostmask))
 		{
-			i->is_global = true;
+			if (!simulate)
+			{
+				/* remove exempt from everyone and force recheck after deleting eline */
+				for (std::vector<User*>::const_iterator u2 = ServerInstance->local_users.begin(); u2 != ServerInstance->local_users.end(); u2++)
+				{
+					User* u = (User*)(*u2);
+					u->exempt = false;
+				}
+
+				delete *i;
+				elines.erase(i);
+				CheckELines(ServerInstance, elines);
+			}
 			return true;
 		}
 	}
+
 	return false;
 }
 
-bool zline_make_global(const char* ipaddr)
+// deletes a q:line, returns true if the line existed and was removed
+
+bool XLineManager::DelQLine(const char* nickname, bool simulate)
 {
-	for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
+	for (std::vector<QLine*>::iterator i = qlines.begin(); i != qlines.end(); i++)
 	{
-		if (!strcasecmp(ipaddr,i->ipaddr))
+		if (!strcasecmp(nickname,(*i)->nick))
 		{
-			i->is_global = true;
+			if (!simulate)
+			{
+				delete *i;
+				qlines.erase(i);
+			}
 			return true;
 		}
 	}
+
 	return false;
 }
 
 // deletes a z:line, returns true if the line existed and was removed
 
-bool del_zline(const char* ipaddr)
+bool XLineManager::DelZLine(const char* ipaddr, bool simulate)
 {
-	for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
+	for (std::vector<ZLine*>::iterator i = zlines.begin(); i != zlines.end(); i++)
 	{
-		if (!strcasecmp(ipaddr,i->ipaddr))
+		if (!strcasecmp(ipaddr,(*i)->ipaddr))
 		{
-			zlines.erase(i);
-			return true;
-		}
-	}
-	for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
-	{
-		if (!strcasecmp(ipaddr,i->ipaddr))
-		{
-			pzlines.erase(i);
+			if (!simulate)
+			{
+				delete *i;
+				zlines.erase(i);
+			}
 			return true;
 		}
 	}
+
 	return false;
 }
 
 // deletes a k:line, returns true if the line existed and was removed
 
-bool del_kline(const char* hostmask)
+bool XLineManager::DelKLine(const char* hostmask, bool simulate)
 {
-	for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
+	IdentHostPair ih = IdentSplit(hostmask);
+	for (std::vector<KLine*>::iterator i = klines.begin(); i != klines.end(); i++)
 	{
-		if (!strcasecmp(hostmask,i->hostmask))
+		if (!strcasecmp(ih.first.c_str(),(*i)->identmask) && !strcasecmp(ih.second.c_str(),(*i)->hostmask))
 		{
-			klines.erase(i);
-			return true;
-		}
-	}
-	for (std::vector<KLine>::iterator i = pklines.begin(); i != pklines.end(); i++)
-	{
-		if (!strcasecmp(hostmask,i->hostmask))
-		{
-			pklines.erase(i);
+			if (!simulate)
+			{
+				delete *i;
+				klines.erase(i);
+			}
 			return true;
 		}
 	}
+
 	return false;
 }
 
 // returns a pointer to the reason if a nickname matches a qline, NULL if it didnt match
 
-char* matches_qline(const char* nick)
+QLine* XLineManager::matches_qline(const char* nick)
 {
 	if (qlines.empty())
 		return NULL;
-	for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
-		if (match(nick,i->nick))
-			return i->reason;
-	for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
-		if (match(nick,i->nick))
-			return i->reason;
+
+	for (std::vector<QLine*>::iterator i = qlines.begin(); i != qlines.end(); i++)
+		if ((*i)->Matches(nick))
+			return (*i);
 	return NULL;
 }
 
 // returns a pointer to the reason if a host matches a gline, NULL if it didnt match
 
-char* matches_gline(const char* host)
+GLine* XLineManager::matches_gline(User* user)
 {
-        if (glines.empty())
-                return NULL;
-	for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
-		if (match(host,i->hostmask))
-			return i->reason;
-	for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
-		if (match(host,i->hostmask))
-			return i->reason;
+	if (glines.empty())
+		return NULL;
+
+	for (std::vector<GLine*>::iterator i = glines.begin(); i != glines.end(); i++)
+	{
+		if ((*i)->Matches(user))
+			return (*i);
+	}
+
 	return NULL;
 }
 
-char* matches_exception(const char* host)
+ELine* XLineManager::matches_exception(User* user)
 {
-        if (elines.empty())
-                return NULL;
-	char host2[MAXBUF];
-	snprintf(host2,MAXBUF,"*@%s",host);
-        for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
-                if ((match(host,i->hostmask)) || (match(host2,i->hostmask)))
-                        return i->reason;
-	for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
-		if ((match(host,i->hostmask)) || (match(host2,i->hostmask)))
-			return i->reason;
-        return NULL;
+	if (elines.empty())
+		return NULL;
+
+	for (std::vector<ELine*>::iterator i = elines.begin(); i != elines.end(); i++)
+	{
+		if ((*i)->Matches(user))
+			return (*i);
+	}
+	return NULL;
 }
 
 
-void gline_set_creation_time(char* host, time_t create_time)
+void XLineManager::gline_set_creation_time(const char* host, time_t create_time)
 {
-	for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
+	for (std::vector<GLine*>::iterator i = glines.begin(); i != glines.end(); i++)
 	{
-		if (!strcasecmp(host,i->hostmask))
+		if (!strcasecmp(host,(*i)->hostmask))
 		{
-			i->set_time = create_time;
+			(*i)->set_time = create_time;
+			(*i)->expiry = create_time + (*i)->duration;
 			return;
 		}
 	}
-	for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
-	{
-		if (!strcasecmp(host,i->hostmask))
-		{
-			i->set_time = create_time;
-			return;
-		}
-	}
-	return ;	
+
+	return ;
 }
 
-void eline_set_creation_time(char* host, time_t create_time)
+void XLineManager::eline_set_creation_time(const char* host, time_t create_time)
 {
-	for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
-	{
-		if (!strcasecmp(host,i->hostmask))
-		{
-			i->set_time = create_time;
-			return;
-		}
-	}
-	for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)	
+	for (std::vector<ELine*>::iterator i = elines.begin(); i != elines.end(); i++)
 	{
-		if (!strcasecmp(host,i->hostmask))
+		if (!strcasecmp(host,(*i)->hostmask))
 		{
-			i->set_time = create_time;
+			(*i)->set_time = create_time;
+			(*i)->expiry = create_time + (*i)->duration;
 			return;
 		}
 	}
+
 	return;
 }
 
-void qline_set_creation_time(char* nick, time_t create_time)
+void XLineManager::qline_set_creation_time(const char* nick, time_t create_time)
 {
-	for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
-	{
-		if (!strcasecmp(nick,i->nick))
-		{
-			i->set_time = create_time;
-			return;
-		}
-	}
-	for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
+	for (std::vector<QLine*>::iterator i = qlines.begin(); i != qlines.end(); i++)
 	{
-		if (!strcasecmp(nick,i->nick))
+		if (!strcasecmp(nick,(*i)->nick))
 		{
-			i->set_time = create_time;
+			(*i)->set_time = create_time;
+			(*i)->expiry = create_time + (*i)->duration;
 			return;
 		}
 	}
+
 	return;
 }
 
-void zline_set_creation_time(char* ip, time_t create_time)
+void XLineManager::zline_set_creation_time(const char* ip, time_t create_time)
 {
-	for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
+	for (std::vector<ZLine*>::iterator i = zlines.begin(); i != zlines.end(); i++)
 	{
-		if (!strcasecmp(ip,i->ipaddr))
+		if (!strcasecmp(ip,(*i)->ipaddr))
 		{
-			i->set_time = create_time;
-			return;
-		}
-	}
-	for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
-	{
-		if (!strcasecmp(ip,i->ipaddr))
-		{
-			i->set_time = create_time;
+			(*i)->set_time = create_time;
+			(*i)->expiry = create_time + (*i)->duration;
 			return;
 		}
 	}
+
 	return;
 }
 
 // returns a pointer to the reason if an ip address matches a zline, NULL if it didnt match
 
-char* matches_zline(const char* ipaddr)
+ZLine* XLineManager::matches_zline(User *u)
 {
-        if (zlines.empty())
-                return NULL;
-	for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
-		if (match(ipaddr,i->ipaddr))
-			return i->reason;
-	for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
-		if (match(ipaddr,i->ipaddr))
-			return i->reason;
-	return NULL;
-}
-
-// returns a pointer to the reason if a host matches a kline, NULL if it didnt match
+	if (zlines.empty())
+		return NULL;
 
-char* matches_kline(const char* host)
-{
-        if (klines.empty())
-                return NULL;
-	for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
-		if (match(host,i->hostmask))
-			return i->reason;
-	for (std::vector<KLine>::iterator i = pklines.begin(); i != pklines.end(); i++)
-		if (match(host,i->hostmask))
-			return i->reason;
+	for (std::vector<ZLine*>::iterator i = zlines.begin(); i != zlines.end(); i++)
+		if ((*i)->Matches(u))
+			return (*i);
 	return NULL;
 }
 
-bool GSortComparison ( const GLine one, const GLine two )
-{
-	return (one.duration + one.set_time) < (two.duration + two.set_time);
-}
+// returns a pointer to the reason if a host matches a kline, NULL if it didnt match
 
-bool ESortComparison ( const ELine one, const ELine two )
+KLine* XLineManager::matches_kline(User* user)
 {
-        return (one.duration + one.set_time) < (two.duration + two.set_time);
-}
+	if (klines.empty())
+		return NULL;
 
-bool ZSortComparison ( const ZLine one, const ZLine two )
-{
-	return (one.duration + one.set_time) < (two.duration + two.set_time);
-}
+	for (std::vector<KLine*>::iterator i = klines.begin(); i != klines.end(); i++)
+	{
+		if ((*i)->Matches(user))
+			return (*i);
+	}
 
-bool KSortComparison ( const KLine one, const KLine two )
-{
-        return (one.duration + one.set_time) < (two.duration + two.set_time);
+	return NULL;
 }
 
-bool QSortComparison ( const QLine one, const QLine two )
+bool XLineManager::XSortComparison(const XLine *one, const XLine *two)
 {
-        return (one.duration + one.set_time) < (two.duration + two.set_time);
+	// account for permanent lines
+	if (one->expiry == 0)
+	{
+		return false;
+	}
+	return (one->expiry) < (two->expiry);
 }
 
 // removes lines that have expired
-
-void expire_lines()
+void XLineManager::expire_lines()
 {
-	time_t current = TIME;
+	time_t current = ServerInstance->Time();
 
-	/* Because we now store all our XLines in sorted order using (i->duration + i->set_time) as a key, this
+	/* Because we now store all our XLines in sorted order using ((*i)->duration + (*i)->set_time) as a key, this
 	 * means that to expire the XLines we just need to do a while, picking off the top few until there are
 	 * none left at the head of the queue that are after the current time.
 	 */
 
-	while ((glines.size()) && (current > (glines.begin()->duration + glines.begin()->set_time)))
+	while ((glines.size()) && (current > (*glines.begin())->expiry) && ((*glines.begin())->duration != 0))
 	{
-		std::vector<GLine>::iterator i = glines.begin();
-		WriteOpers("Expiring timed G-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+		std::vector<GLine*>::iterator i = glines.begin();
+		ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed G-Line %s@%s (set by %s %d seconds ago)",(*i)->identmask,(*i)->hostmask,(*i)->source,(*i)->duration);
 		glines.erase(i);
 	}
 
-	while ((elines.size()) && (current > (elines.begin()->duration + elines.begin()->set_time)))
+	while ((elines.size()) && (current > (*elines.begin())->expiry) && ((*elines.begin())->duration != 0))
 	{
-		std::vector<ELine>::iterator i = elines.begin();
-		WriteOpers("Expiring timed E-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+		std::vector<ELine*>::iterator i = elines.begin();
+		ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed E-Line %s@%s (set by %s %d seconds ago)",(*i)->identmask,(*i)->hostmask,(*i)->source,(*i)->duration);
 		elines.erase(i);
 	}
 
-	while ((zlines.size()) && (current > (zlines.begin()->duration + zlines.begin()->set_time)))
+	while ((zlines.size()) && (current > (*zlines.begin())->expiry) && ((*zlines.begin())->duration != 0))
 	{
-		std::vector<ZLine>::iterator i = zlines.begin();
-		WriteOpers("Expiring timed Z-Line %s (set by %s %d seconds ago)",i->ipaddr,i->source,i->duration);
+		std::vector<ZLine*>::iterator i = zlines.begin();
+		ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed Z-Line %s (set by %s %d seconds ago)",(*i)->ipaddr,(*i)->source,(*i)->duration);
 		zlines.erase(i);
 	}
 
-	while ((klines.size()) && (current > (klines.begin()->duration + klines.begin()->set_time)))
+	while ((klines.size()) && (current > (*klines.begin())->expiry) && ((*klines.begin())->duration != 0))
 	{
-		std::vector<KLine>::iterator i = klines.begin();
-		WriteOpers("Expiring timed K-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+		std::vector<KLine*>::iterator i = klines.begin();
+		ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed K-Line %s@%s (set by %s %d seconds ago)",(*i)->identmask,(*i)->hostmask,(*i)->source,(*i)->duration);
 		klines.erase(i);
 	}
 
-	while ((qlines.size()) && (current > (qlines.begin()->duration + qlines.begin()->set_time)))
+	while ((qlines.size()) && (current > (*qlines.begin())->expiry) && ((*qlines.begin())->duration != 0))
 	{
-		std::vector<QLine>::iterator i = qlines.begin();
-		WriteOpers("Expiring timed Q-Line %s (set by %s %d seconds ago)",i->nick,i->source,i->duration);
+		std::vector<QLine*>::iterator i = qlines.begin();
+		ServerInstance->SNO->WriteToSnoMask('x',"Expiring timed Q-Line %s (set by %s %d seconds ago)",(*i)->nick,(*i)->source,(*i)->duration);
 		qlines.erase(i);
 	}
-	
+
 }
 
 // applies lines, removing clients and changing nicks etc as applicable
+void XLineManager::ApplyLines()
+{
+	for (std::vector<User*>::const_iterator u2 = ServerInstance->local_users.begin(); u2 != ServerInstance->local_users.end(); u2++)
+	{
+		User* u = (User*)(*u2);
+
+		for (std::vector<XLine *>::iterator i = pending_lines.begin(); i != pending_lines.end(); i++)
+		{
+			XLine *x = *i;
+			if (x->Matches(u))
+				x->Apply(u);
+		}
+	}
+
+	pending_lines.clear();
+}
+
+void XLineManager::stats_k(User* user, string_list &results)
+{
+	std::string sn = ServerInstance->Config->ServerName;
+	for (std::vector<KLine*>::iterator i = klines.begin(); i != klines.end(); i++)
+		results.push_back(sn+" 216 "+user->nick+" :"+(*i)->identmask+"@"+(*i)->hostmask+" "+ConvToStr((*i)->set_time)+" "+ConvToStr((*i)->duration)+" "+(*i)->source+" :"+(*i)->reason);
+}
+
+void XLineManager::stats_g(User* user, string_list &results)
+{
+	std::string sn = ServerInstance->Config->ServerName;
+	for (std::vector<GLine*>::iterator i = glines.begin(); i != glines.end(); i++)
+		results.push_back(sn+" 223 "+user->nick+" :"+(*i)->identmask+"@"+(*i)->hostmask+" "+ConvToStr((*i)->set_time)+" "+ConvToStr((*i)->duration)+" "+(*i)->source+" :"+(*i)->reason);
+}
 
-void apply_lines()
+void XLineManager::stats_q(User* user, string_list &results)
+{
+	std::string sn = ServerInstance->Config->ServerName;
+	for (std::vector<QLine*>::iterator i = qlines.begin(); i != qlines.end(); i++)
+		results.push_back(sn+" 217 "+user->nick+" :"+(*i)->nick+" "+ConvToStr((*i)->set_time)+" "+ConvToStr((*i)->duration)+" "+(*i)->source+" :"+(*i)->reason);
+}
+
+void XLineManager::stats_z(User* user, string_list &results)
+{
+	std::string sn = ServerInstance->Config->ServerName;
+	for (std::vector<ZLine*>::iterator i = zlines.begin(); i != zlines.end(); i++)
+		results.push_back(sn+" 223 "+user->nick+" :"+(*i)->ipaddr+" "+ConvToStr((*i)->set_time)+" "+ConvToStr((*i)->duration)+" "+(*i)->source+" :"+(*i)->reason);
+}
+
+void XLineManager::stats_e(User* user, string_list &results)
+{
+	std::string sn = ServerInstance->Config->ServerName;
+	for (std::vector<ELine*>::iterator i = elines.begin(); i != elines.end(); i++)
+		results.push_back(sn+" 223 "+user->nick+" :"+(*i)->identmask+"@"+(*i)->hostmask+" "+ConvToStr((*i)->set_time)+" "+ConvToStr((*i)->duration)+" "+(*i)->source+" :"+(*i)->reason);
+}
+
+XLineManager::XLineManager(InspIRCd* Instance) : ServerInstance(Instance)
+{
+}
+
+bool XLine::Matches(const std::string &str)
+{
+	return false;
+}
+
+void XLine::Apply(User* u)
+{
+}
+
+void XLine::DefaultApply(User* u, char line)
 {
-	bool go_again = true;
 	char reason[MAXBUF];
-	char host[MAXBUF];
-	
-	if ((!glines.size()) && (!klines.size()) && (!zlines.size()) && (!qlines.size()))
-		return;
-	
-	while (go_again)
+	snprintf(reason, MAXBUF, "%c-Lined: %s", line, this->reason);
+	if (*ServerInstance->Config->MoronBanner)
+		u->WriteServ("NOTICE %s :*** %s", u->nick, ServerInstance->Config->MoronBanner);
+	if (ServerInstance->Config->HideBans)
+		User::QuitUser(ServerInstance, u, line + std::string("-Lined"), reason);
+	else
+		User::QuitUser(ServerInstance, u, reason);
+}
+
+bool KLine::Matches(User *u)
+{
+	if (u->exempt)
+		return false;
+
+	if ((match(u->ident, this->identmask)))
 	{
-		go_again = false;
-		for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
+		if ((match(u->host, this->hostmask, true)) || (match(u->GetIPString(), this->hostmask, true)))
 		{
-			if (!strcasecmp(u->second->server,ServerName))
-			{
-				snprintf(host,MAXBUF,"%s@%s",u->second->ident,u->second->host);
-				if (elines.size())
-				{
-					// ignore people matching exempts
-					if (matches_exception(host))
-						continue;
-				}
-				if (glines.size() || pglines.size())
-				{
-					char* check = matches_gline(host);
-					if (check)
-					{
-						WriteOpers("*** User %s matches G-Line: %s",u->second->registered == 7 ? u->second->nick:"<unknown>",check);
-						snprintf(reason,MAXBUF,"G-Lined: %s",check);
-						kill_link(u->second,reason);
-						go_again = true;
-						break;
-					}
-				}
-				if (klines.size() || pklines.size())
-				{
-					char* check = matches_kline(host);
-					if (check)
-					{
-						WriteOpers("*** User %s matches K-Line: %s",u->second->registered == 7 ? u->second->nick:"<unknown>",check);
-						snprintf(reason,MAXBUF,"K-Lined: %s",check);
-						kill_link(u->second,reason);
-						go_again = true;
-						break;
-					}
-				}
-				if (qlines.size() || pqlines.size())
-				{
-					char* check = matches_qline(u->second->nick);
-					if (check)
-					{
-						snprintf(reason,MAXBUF,"Matched Q-Lined nick: %s",check);
-						WriteOpers("*** Q-Lined nickname %s from %s: %s",u->second->registered == 7 ? u->second->nick:"<unknown>",u->second->host,check);
-						kill_link(u->second,reason);
-						go_again = true;
-						break;
-					}
-				}
-				if (zlines.size() || pzlines.size())
-				{
-					char* check = matches_zline(u->second->ip);
-					if (check)
-					{
-						snprintf(reason,MAXBUF,"Z-Lined: %s",check);
-						WriteOpers("*** User %s matches Z-Line: %s",u->second->registered == 7 ? u->second->nick:"<unknown>",u->second->host,check);
-						kill_link(u->second,reason);
-						go_again = true;
-						break;
-					}
-				}
-			}
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void KLine::Apply(User* u)
+{
+	DefaultApply(u, 'K');
+}
+
+bool GLine::Matches(User *u)
+{
+	if (u->exempt)
+		return false;
+
+	if ((match(u->ident, this->identmask)))
+	{
+		if ((match(u->host, this->hostmask, true)) || (match(u->GetIPString(), this->hostmask, true)))
+		{
+			return true;
 		}
 	}
+
+	return false;
 }
 
-void stats_k(userrec* user)
+void GLine::Apply(User* u)
+{       
+	DefaultApply(u, 'G');
+}
+
+bool ELine::Matches(User *u)
 {
-	for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
-		WriteServ(user->fd,"216 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
-	for (std::vector<KLine>::iterator i = pklines.begin(); i != pklines.end(); i++)
-		WriteServ(user->fd,"216 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
+	if (u->exempt)
+		return false;
+
+	if ((match(u->ident, this->identmask)))
+	{
+		if ((match(u->host, this->hostmask, true)) || (match(u->GetIPString(), this->hostmask, true)))
+		{
+			return true;
+		}
+	}
+
+	return false;
 }
 
-void stats_g(userrec* user)
+bool ZLine::Matches(User *u)
 {
-	for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
-		WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
-	for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
-		WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
+	if (u->exempt)
+		return false;
+
+	if (match(u->GetIPString(), this->ipaddr, true))
+		return true;
+	else
+		return false;
 }
 
-void stats_q(userrec* user)
+void ZLine::Apply(User* u)
+{       
+	DefaultApply(u, 'Z');
+}
+
+
+bool QLine::Matches(User *u)
 {
-	for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
-		WriteServ(user->fd,"217 %s :%s %d %d %s %s",user->nick,i->nick,i->set_time,i->duration,i->source,i->reason);
-	for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
-		WriteServ(user->fd,"217 %s :%s %d %d %s %s",user->nick,i->nick,i->set_time,i->duration,i->source,i->reason);
+	if (u->exempt)
+		return false;
+
+	if (match(u->nick, this->nick))
+		return true;
+
+	return false;
 }
 
-void stats_z(userrec* user)
+void QLine::Apply(User* u)
+{       
+	/* Can we force the user to their uid here instead? */
+	DefaultApply(u, 'Q');
+}
+
+
+bool ZLine::Matches(const std::string &str)
 {
-	for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
-		WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->ipaddr,i->set_time,i->duration,i->source,i->reason);
-	for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
-		WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->ipaddr,i->set_time,i->duration,i->source,i->reason);
+	if (match(str.c_str(), this->ipaddr, true))
+		return true;
+	else
+		return false;
 }
 
-void stats_e(userrec* user)
+bool QLine::Matches(const std::string &str)
 {
-        for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
-                WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
-	for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
-		WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
+	if (match(str.c_str(), this->nick))
+		return true;
+
+	return false;
 }
+