X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fconfigreader.cpp;h=b5d999f1d2e543ec519fa3de82b62c808ef085ea;hb=84083a73e80734e39892f44411549d2381654c95;hp=ed1216c8b10652f60af5b1d6aa9ab39ea30b1a85;hpb=5a956ba84649aca12a3fc2b28d3b786d4904e408;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/configreader.cpp b/src/configreader.cpp
index ed1216c8b..b5d999f1d 100644
--- a/src/configreader.cpp
+++ b/src/configreader.cpp
@@ -6,7 +6,7 @@
  * See: http://www.inspircd.org/wiki/index.php/Credits
  *
  * This program is free but copyrighted software; see
- *            the file COPYING for details.
+ *	    the file COPYING for details.
  *
  * ---------------------------------------------------
  */
@@ -31,6 +31,7 @@ std::vector<std::string> old_module_names, new_module_names, added_modules, remo
 
 /* Needs forward declaration */
 bool ValidateDnsServer(ServerConfig* conf, const char* tag, const char* value, ValueItem &data);
+bool DoneELine(ServerConfig* conf, const char* tag);
 
 ServerConfig::ServerConfig(InspIRCd* Instance) : ServerInstance(Instance)
 {
@@ -181,6 +182,104 @@ bool NoValidation(ServerConfig*, const char*, const char*, ValueItem&)
 	return true;
 }
 
+bool DoneConfItem(ServerConfig* conf, const char* tag)
+{
+	return true;
+}
+
+void ServerConfig::ValidateNoSpaces(const char* p, const std::string &tag, const std::string &val)
+{
+	for (const char* ptr = p; *ptr; ++ptr)
+	{
+		if (*ptr == ' ')
+			throw CoreException("The value of <"+tag+":"+val+"> cannot contain spaces");
+	}
+}
+
+/* NOTE: Before anyone asks why we're not using inet_pton for this, it is because inet_pton and friends do not return so much detail,
+ * even in strerror(errno). They just return 'yes' or 'no' to an address without such detail as to whats WRONG with the address.
+ * Because ircd users arent as technical as they used to be (;)) we are going to give more of a useful error message.
+ */
+void ServerConfig::ValidateIP(const char* p, const std::string &tag, const std::string &val, bool wild)
+{
+	int num_dots = 0;
+	int num_seps = 0;
+	int not_numbers = false;
+	int not_hex = false;
+
+	if (*p)
+	{
+		if (*p == '.')
+			throw CoreException("The value of <"+tag+":"+val+"> is not an IP address");
+
+		for (const char* ptr = p; *ptr; ++ptr)
+		{
+			if (wild && (*ptr == '*' || *ptr == '?' || *ptr == '/'))
+				continue;
+
+			if (*ptr != ':' && *ptr != '.')
+			{
+				if (*ptr < '0' || *ptr > '9')
+					not_numbers = true;
+				if ((*ptr < '0' || *ptr > '9') && (toupper(*ptr) < 'A' || toupper(*ptr) > 'F'))
+					not_hex = true;
+			}
+			switch (*ptr)
+			{
+				case ' ':
+					throw CoreException("The value of <"+tag+":"+val+"> is not an IP address");
+				case '.':
+					num_dots++;
+				break;
+				case ':':
+					num_seps++;
+				break;
+			}
+		}
+
+		if (num_dots > 3)
+			throw CoreException("The value of <"+tag+":"+val+"> is an IPv4 address with too many fields!");
+
+		if (num_seps > 8)
+			throw CoreException("The value of <"+tag+":"+val+"> is an IPv6 address with too many fields!");
+
+		if (num_seps == 0 && num_dots < 3 && !wild)
+			throw CoreException("The value of <"+tag+":"+val+"> looks to be a malformed IPv4 address");
+
+		if (num_seps == 0 && num_dots == 3 && not_numbers)
+			throw CoreException("The value of <"+tag+":"+val+"> contains non-numeric characters in an IPv4 address");
+
+		if (num_seps != 0 && not_hex)
+			throw CoreException("The value of <"+tag+":"+val+"> contains non-hexdecimal characters in an IPv6 address");
+
+		if (num_seps != 0 && num_dots != 3 && num_dots != 0 && !wild)
+			throw CoreException("The value of <"+tag+":"+val+"> is a malformed IPv6 4in6 address");
+	}
+}
+
+void ServerConfig::ValidateHostname(const char* p, const std::string &tag, const std::string &val)
+{
+	int num_dots = 0;
+	if (*p)
+	{
+		if (*p == '.')
+			throw CoreException("The value of <"+tag+":"+val+"> is not a valid hostname");
+		for (const char* ptr = p; *ptr; ++ptr)
+		{
+			switch (*ptr)
+			{
+				case ' ':
+					throw CoreException("The value of <"+tag+":"+val+"> is not a valid hostname");
+				case '.':
+					num_dots++;
+				break;
+			}
+		}
+		if (num_dots == 0)
+			throw CoreException("The value of <"+tag+":"+val+"> is not a valid hostname");
+	}
+}
+
 bool ValidateMaxTargets(ServerConfig* conf, const char*, const char*, ValueItem &data)
 {
 	if ((data.GetInteger() < 0) || (data.GetInteger() > 31))
@@ -379,13 +478,7 @@ bool ValidateInvite(ServerConfig* conf, const char*, const char*, ValueItem &dat
 
 bool ValidateSID(ServerConfig* conf, const char*, const char*, ValueItem &data)
 {
-	int sid = data.GetInteger();
-	if ((sid > 999) || (sid < 0))
-	{
-		sid = sid % 1000;
-		data.Set(sid);
-		conf->GetInstance()->Log(DEFAULT,"WARNING: Server ID is less than 0 or greater than 999. Set to %d", sid);
-	}
+//	std::string  sid = data.GetString();
 	return true;
 }
 
@@ -428,20 +521,28 @@ bool InitConnect(ServerConfig* conf, const char*)
 		conf->GetInstance()->Log(DEBUG, "Address of class is %p", c);
 	}
 
-	for (ClassVector::iterator i = conf->Classes.begin(); i != conf->Classes.end(); i++)
+	for (ClassVector::iterator i = conf->Classes.begin(); i != conf->Classes.end() ; )
 	{
-		ConnectClass *c = *i;
+		ConnectClass* c = *i;
 
 		/* only delete a class with refcount 0 */
 		if (c->RefCount == 0)
 		{
 			conf->GetInstance()->Log(DEFAULT, "Removing connect class, refcount is 0!");
+			
+			/* This was causing a crash, because we'd set i to .begin() just here, but then the for loop's increment would
+			 * set it to .begin() + 1. Which if it was already the last thing in the list, wasn't good.
+			 * Now the increment is in the else { } below.
+			 */
 			conf->Classes.erase(i);
 			i = conf->Classes.begin(); // start over so we don't trample on a bad iterator
 		}
-
-		/* also mark all existing classes disabled, if they still exist in the conf, they will be reenabled. */
-		c->SetDisabled(true);
+		else
+		{
+			/* also mark all existing classes disabled, if they still exist in the conf, they will be reenabled. */
+			c->SetDisabled(true);
+			i++;
+		}
 	}
 
 	return true;
@@ -565,14 +666,10 @@ bool DoneULine(ServerConfig*, const char*)
  */
 bool InitModule(ServerConfig* conf, const char*)
 {
-	old_module_names.clear();
+	old_module_names = conf->GetInstance()->Modules->GetAllModuleNames(0);
 	new_module_names.clear();
 	added_modules.clear();
 	removed_modules.clear();
-	for (std::vector<std::string>::iterator t = conf->module_names.begin(); t != conf->module_names.end(); t++)
-	{
-		old_module_names.push_back(*t);
-	}
 	return true;
 }
 
@@ -684,72 +781,76 @@ void ServerConfig::ReportConfigError(const std::string &errormessage, bool bail,
 	}
 }
 
-void ServerConfig::Read(bool bail, User* user)
+void ServerConfig::Read(bool bail, User* user, int pass)
 {
+	int rem = 0, add = 0;           /* Number of modules added, number of modules removed */
+
 	static char debug[MAXBUF];	/* Temporary buffer for debugging value */
 	static char maxkeep[MAXBUF];	/* Temporary buffer for WhoWasMaxKeep value */
 	static char hidemodes[MAXBUF];	/* Modes to not allow listing from users below halfop */
 	static char exemptchanops[MAXBUF];	/* Exempt channel ops from these modes */
 	static char announceinvites[MAXBUF];	/* options:announceinvites setting */
-	int rem = 0, add = 0;		/* Number of modules added, number of modules removed */
-	std::ostringstream errstr;	/* String stream containing the error output */
+	errstr.clear();
 
 	/* These tags MUST occur and must ONLY occur once in the config file */
 	static char* Once[] = { "server", "admin", "files", "power", "options", NULL };
 
 	/* These tags can occur ONCE or not at all */
 	InitialConfig Values[] = {
-		{"options",	"softlimit",	MAXCLIENTS_S,		new ValueContainerUInt (&this->SoftLimit),		DT_INTEGER, ValidateSoftLimit},
-		{"options",	"somaxconn",	SOMAXCONN_S,		new ValueContainerInt  (&this->MaxConn),		DT_INTEGER, ValidateMaxConn},
-		{"options",	"moronbanner",	"Youre banned!",	new ValueContainerChar (this->MoronBanner),		DT_CHARPTR, NoValidation},
-		{"server",	"name",		"",			new ValueContainerChar (this->ServerName),		DT_CHARPTR, ValidateServerName},
-		{"server",	"description",	"Configure Me",		new ValueContainerChar (this->ServerDesc),		DT_CHARPTR, NoValidation},
-		{"server",	"network",	"Network",		new ValueContainerChar (this->Network),			DT_CHARPTR, NoValidation},
-		{"server",	"id",		"0",			new ValueContainerInt  (&this->sid),			DT_INTEGER, ValidateSID},
-		{"admin",	"name",		"",			new ValueContainerChar (this->AdminName),		DT_CHARPTR, NoValidation},
-		{"admin",	"email",	"Mis@configu.red",	new ValueContainerChar (this->AdminEmail),		DT_CHARPTR, NoValidation},
-		{"admin",	"nick",		"Misconfigured",	new ValueContainerChar (this->AdminNick),		DT_CHARPTR, NoValidation},
-		{"files",	"motd",		"",			new ValueContainerChar (this->motd),			DT_CHARPTR, ValidateMotd},
-		{"files",	"rules",	"",			new ValueContainerChar (this->rules),			DT_CHARPTR, ValidateRules},
-		{"power",	"diepass",	"",			new ValueContainerChar (this->diepass),			DT_CHARPTR, ValidateNotEmpty},
-		{"power",	"pause",	"",			new ValueContainerInt  (&this->DieDelay),		DT_INTEGER, NoValidation},
-		{"power",	"restartpass",	"",			new ValueContainerChar (this->restartpass),		DT_CHARPTR, ValidateNotEmpty},
-		{"options",	"prefixquit",	"",			new ValueContainerChar (this->PrefixQuit),		DT_CHARPTR, NoValidation},
-		{"options",	"suffixquit",	"",			new ValueContainerChar (this->SuffixQuit),		DT_CHARPTR, NoValidation},
-		{"options",	"fixedquit",	"",			new ValueContainerChar (this->FixedQuit),		DT_CHARPTR, NoValidation},
-		{"options",	"loglevel",	"default",		new ValueContainerChar (debug),				DT_CHARPTR, ValidateLogLevel},
-		{"options",	"netbuffersize","10240",		new ValueContainerInt  (&this->NetBufferSize),		DT_INTEGER, ValidateNetBufferSize},
-		{"options",	"maxwho",	"128",			new ValueContainerInt  (&this->MaxWhoResults),		DT_INTEGER, ValidateMaxWho},
-		{"options",	"allowhalfop",	"0",			new ValueContainerBool (&this->AllowHalfop),		DT_BOOLEAN, NoValidation},
-		{"dns",		"server",	"",			new ValueContainerChar (this->DNSServer),		DT_CHARPTR, DNSServerValidator},
-		{"dns",		"timeout",	"5",			new ValueContainerInt  (&this->dns_timeout),		DT_INTEGER, NoValidation},
-		{"options",	"moduledir",	MOD_PATH,		new ValueContainerChar (this->ModPath),			DT_CHARPTR, NoValidation},
-		{"disabled",	"commands",	"",			new ValueContainerChar (this->DisabledCommands),	DT_CHARPTR, NoValidation},
-		{"options",	"userstats",	"",			new ValueContainerChar (this->UserStats),		DT_CHARPTR, NoValidation},
-		{"options",	"customversion","",			new ValueContainerChar (this->CustomVersion),		DT_CHARPTR, NoValidation},
-		{"options",	"hidesplits",	"0",			new ValueContainerBool (&this->HideSplits),		DT_BOOLEAN, NoValidation},
-		{"options",	"hidebans",	"0",			new ValueContainerBool (&this->HideBans),		DT_BOOLEAN, NoValidation},
-		{"options",	"hidewhois",	"",			new ValueContainerChar (this->HideWhoisServer),		DT_CHARPTR, NoValidation},
-		{"options",	"hidekills",	"",			new ValueContainerChar (this->HideKillsServer),		DT_CHARPTR, NoValidation},
-		{"options",	"operspywhois",	"0",			new ValueContainerBool (&this->OperSpyWhois),		DT_BOOLEAN, NoValidation},
-		{"options",	"nouserdns",	"0",			new ValueContainerBool (&this->NoUserDns),		DT_BOOLEAN, NoValidation},
-		{"options",	"syntaxhints",	"0",			new ValueContainerBool (&this->SyntaxHints),		DT_BOOLEAN, NoValidation},
-		{"options",	"cyclehosts",	"0",			new ValueContainerBool (&this->CycleHosts),		DT_BOOLEAN, NoValidation},
-		{"options",	"ircumsgprefix","0",			new ValueContainerBool (&this->UndernetMsgPrefix),	DT_BOOLEAN, NoValidation},
-		{"options",	"announceinvites", "1",			new ValueContainerChar (announceinvites),		DT_CHARPTR, ValidateInvite},
-		{"options",	"hostintopic",	"1",			new ValueContainerBool (&this->FullHostInTopic),	DT_BOOLEAN, NoValidation},
-		{"options",	"hidemodes",	"",			new ValueContainerChar (hidemodes),			DT_CHARPTR, ValidateModeLists},
-		{"options",	"exemptchanops","",			new ValueContainerChar (exemptchanops),			DT_CHARPTR, ValidateExemptChanOps},
-		{"options",	"maxtargets",	"20",			new ValueContainerUInt (&this->MaxTargets),		DT_INTEGER, ValidateMaxTargets},
-		{"options",	"defaultmodes", "nt",			new ValueContainerChar (this->DefaultModes),		DT_CHARPTR, NoValidation},
-		{"pid",		"file",		"",			new ValueContainerChar (this->PID),			DT_CHARPTR, NoValidation},
-		{"whowas",	"groupsize",	"10",			new ValueContainerInt  (&this->WhoWasGroupSize),	DT_INTEGER, NoValidation},
-		{"whowas",	"maxgroups",	"10240",		new ValueContainerInt  (&this->WhoWasMaxGroups),	DT_INTEGER, NoValidation},
-		{"whowas",	"maxkeep",	"3600",			new ValueContainerChar (maxkeep),			DT_CHARPTR, ValidateWhoWas},
-		{"die",		"value",	"",			new ValueContainerChar (this->DieValue),		DT_CHARPTR, NoValidation},
-		{"channels",	"users",	"20",			new ValueContainerUInt (&this->MaxChans),		DT_INTEGER, NoValidation},
-		{"channels",	"opers",	"60",			new ValueContainerUInt (&this->OperMaxChans),		DT_INTEGER, NoValidation},
-		{NULL,		NULL,		NULL,			NULL,							DT_NOTHING, NoValidation}
+		{"options",	"softlimit",	MAXCLIENTS_S,		new ValueContainerUInt (&this->SoftLimit),		DT_INTEGER,  ValidateSoftLimit},
+		{"options",	"somaxconn",	SOMAXCONN_S,		new ValueContainerInt  (&this->MaxConn),		DT_INTEGER,  ValidateMaxConn},
+		{"options",	"moronbanner",	"Youre banned!",	new ValueContainerChar (this->MoronBanner),		DT_CHARPTR,  NoValidation},
+		{"server",	"name",		"",			new ValueContainerChar (this->ServerName),		DT_HOSTNAME, ValidateServerName},
+		{"server",	"description",	"Configure Me",		new ValueContainerChar (this->ServerDesc),		DT_CHARPTR,  NoValidation},
+		{"server",	"network",	"Network",		new ValueContainerChar (this->Network),			DT_NOSPACES, NoValidation},
+		{"server",	"id",		"",			new ValueContainerChar (this->sid),			DT_CHARPTR,  ValidateSID},
+		{"admin",	"name",		"",			new ValueContainerChar (this->AdminName),		DT_CHARPTR,  NoValidation},
+		{"admin",	"email",	"Mis@configu.red",	new ValueContainerChar (this->AdminEmail),		DT_CHARPTR,  NoValidation},
+		{"admin",	"nick",		"Misconfigured",	new ValueContainerChar (this->AdminNick),		DT_CHARPTR,  NoValidation},
+		{"files",	"motd",		"",			new ValueContainerChar (this->motd),			DT_CHARPTR,  ValidateMotd},
+		{"files",	"rules",	"",			new ValueContainerChar (this->rules),			DT_CHARPTR,  ValidateRules},
+		{"power",	"diepass",	"",			new ValueContainerChar (this->diepass),			DT_CHARPTR,  ValidateNotEmpty},
+		{"power",	"pause",	"",			new ValueContainerInt  (&this->DieDelay),		DT_INTEGER,  NoValidation},
+		{"power",	"restartpass",	"",			new ValueContainerChar (this->restartpass),		DT_CHARPTR,  ValidateNotEmpty},
+		{"options",	"prefixquit",	"",			new ValueContainerChar (this->PrefixQuit),		DT_CHARPTR,  NoValidation},
+		{"options",	"suffixquit",	"",			new ValueContainerChar (this->SuffixQuit),		DT_CHARPTR,  NoValidation},
+		{"options",	"fixedquit",	"",			new ValueContainerChar (this->FixedQuit),		DT_CHARPTR,  NoValidation},
+		{"options",	"prefixpart",	"",			new ValueContainerChar (this->PrefixPart),		DT_CHARPTR,  NoValidation},
+		{"options",	"suffixpart",	"",			new ValueContainerChar (this->SuffixPart),		DT_CHARPTR,  NoValidation},
+		{"options",	"fixedpart",	"",			new ValueContainerChar (this->FixedPart),		DT_CHARPTR,  NoValidation},
+		{"options",	"loglevel",	"default",		new ValueContainerChar (debug),				DT_CHARPTR,  ValidateLogLevel},
+		{"options",	"netbuffersize","10240",		new ValueContainerInt  (&this->NetBufferSize),		DT_INTEGER,  ValidateNetBufferSize},
+		{"options",	"maxwho",	"128",			new ValueContainerInt  (&this->MaxWhoResults),		DT_INTEGER,  ValidateMaxWho},
+		{"options",	"allowhalfop",	"0",			new ValueContainerBool (&this->AllowHalfop),		DT_BOOLEAN,  NoValidation},
+		{"dns",		"server",	"",			new ValueContainerChar (this->DNSServer),		DT_IPADDRESS,DNSServerValidator},
+		{"dns",		"timeout",	"5",			new ValueContainerInt  (&this->dns_timeout),		DT_INTEGER,  NoValidation},
+		{"options",	"moduledir",	MOD_PATH,		new ValueContainerChar (this->ModPath),			DT_CHARPTR,  NoValidation},
+		{"disabled",	"commands",	"",			new ValueContainerChar (this->DisabledCommands),	DT_CHARPTR,  NoValidation},
+		{"options",	"userstats",	"",			new ValueContainerChar (this->UserStats),		DT_CHARPTR,  NoValidation},
+		{"options",	"customversion","",			new ValueContainerChar (this->CustomVersion),		DT_CHARPTR,  NoValidation},
+		{"options",	"hidesplits",	"0",			new ValueContainerBool (&this->HideSplits),		DT_BOOLEAN,  NoValidation},
+		{"options",	"hidebans",	"0",			new ValueContainerBool (&this->HideBans),		DT_BOOLEAN,  NoValidation},
+		{"options",	"hidewhois",	"",			new ValueContainerChar (this->HideWhoisServer),		DT_NOSPACES, NoValidation},
+		{"options",	"hidekills",	"",			new ValueContainerChar (this->HideKillsServer),		DT_NOSPACES,  NoValidation},
+		{"options",	"operspywhois",	"0",			new ValueContainerBool (&this->OperSpyWhois),		DT_BOOLEAN,  NoValidation},
+		{"options",	"nouserdns",	"0",			new ValueContainerBool (&this->NoUserDns),		DT_BOOLEAN,  NoValidation},
+		{"options",	"syntaxhints",	"0",			new ValueContainerBool (&this->SyntaxHints),		DT_BOOLEAN,  NoValidation},
+		{"options",	"cyclehosts",	"0",			new ValueContainerBool (&this->CycleHosts),		DT_BOOLEAN,  NoValidation},
+		{"options",	"ircumsgprefix","0",			new ValueContainerBool (&this->UndernetMsgPrefix),	DT_BOOLEAN,  NoValidation},
+		{"options",	"announceinvites", "1",			new ValueContainerChar (announceinvites),		DT_CHARPTR,  ValidateInvite},
+		{"options",	"hostintopic",	"1",			new ValueContainerBool (&this->FullHostInTopic),	DT_BOOLEAN,  NoValidation},
+		{"options",	"hidemodes",	"",			new ValueContainerChar (hidemodes),			DT_CHARPTR,  ValidateModeLists},
+		{"options",	"exemptchanops","",			new ValueContainerChar (exemptchanops),			DT_CHARPTR,  ValidateExemptChanOps},
+		{"options",	"maxtargets",	"20",			new ValueContainerUInt (&this->MaxTargets),		DT_INTEGER,  ValidateMaxTargets},
+		{"options",	"defaultmodes", "nt",			new ValueContainerChar (this->DefaultModes),		DT_CHARPTR,  NoValidation},
+		{"pid",		"file",		"",			new ValueContainerChar (this->PID),			DT_CHARPTR,  NoValidation},
+		{"whowas",	"groupsize",	"10",			new ValueContainerInt  (&this->WhoWasGroupSize),	DT_INTEGER,  NoValidation},
+		{"whowas",	"maxgroups",	"10240",		new ValueContainerInt  (&this->WhoWasMaxGroups),	DT_INTEGER,  NoValidation},
+		{"whowas",	"maxkeep",	"3600",			new ValueContainerChar (maxkeep),			DT_CHARPTR,  ValidateWhoWas},
+		{"die",		"value",	"",			new ValueContainerChar (this->DieValue),		DT_CHARPTR,  NoValidation},
+		{"channels",	"users",	"20",			new ValueContainerUInt (&this->MaxChans),		DT_INTEGER,  NoValidation},
+		{"channels",	"opers",	"60",			new ValueContainerUInt (&this->OperMaxChans),		DT_INTEGER,  NoValidation},
+		{NULL,		NULL,		NULL,			NULL,							DT_NOTHING,  NoValidation}
 	};
 
 	/* These tags can occur multiple times, and therefore they have special code to read them
@@ -764,17 +865,19 @@ void ServerConfig::Read(bool bail, User* user)
 				NULL},
 				{"",		"",		"",		"",		"120",		"",
 				 "",		"",		"",		"3",		"3",		"0",
-				 "",		"",		"0",            "0",
+				 "",		"",		"0",	    "0",
 				 NULL},
-				{DT_CHARPTR,	DT_CHARPTR,	DT_CHARPTR,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,
-				 DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,
-				 DT_CHARPTR,	DT_CHARPTR,	DT_INTEGER,     DT_INTEGER},
+				{DT_IPADDRESS|DT_ALLOW_WILD,
+						DT_IPADDRESS|DT_ALLOW_WILD,
+								DT_CHARPTR,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,
+				DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,
+				DT_NOSPACES,	DT_NOSPACES,	DT_INTEGER,     DT_INTEGER},
 				InitConnect, DoConnect, DoneConnect},
 
 		{"uline",
 				{"server",	"silent",	NULL},
 				{"",		"0",		NULL},
-				{DT_CHARPTR,	DT_BOOLEAN},
+				{DT_HOSTNAME,	DT_BOOLEAN},
 				InitULine,DoULine,DoneULine},
 
 		{"banlist",
@@ -792,39 +895,39 @@ void ServerConfig::Read(bool bail, User* user)
 		{"badip",
 				{"reason",	"ipmask",	NULL},
 				{"No reason",	"",		NULL},
-				{DT_CHARPTR,	DT_CHARPTR},
-				InitXLine, DoZLine, DoneZLine},
+				{DT_CHARPTR,	DT_IPADDRESS|DT_ALLOW_WILD},
+				InitXLine, DoZLine, DoneConfItem},
 
 		{"badnick",
 				{"reason",	"nick",		NULL},
 				{"No reason",	"",		NULL},
 				{DT_CHARPTR,	DT_CHARPTR},
-				InitXLine, DoQLine, DoneQLine},
-
+				InitXLine, DoQLine, DoneConfItem},
+	
 		{"badhost",
 				{"reason",	"host",		NULL},
 				{"No reason",	"",		NULL},
 				{DT_CHARPTR,	DT_CHARPTR},
-				InitXLine, DoKLine, DoneKLine},
+				InitXLine, DoKLine, DoneConfItem},
 
 		{"exception",
 				{"reason",	"host",		NULL},
 				{"No reason",	"",		NULL},
 				{DT_CHARPTR,	DT_CHARPTR},
 				InitXLine, DoELine, DoneELine},
-
+	
 		{"type",
 				{"name",	"classes",	NULL},
 				{"",		"",		NULL},
-				{DT_CHARPTR,	DT_CHARPTR},
+				{DT_NOSPACES,	DT_CHARPTR},
 				InitTypes, DoType, DoneClassesAndTypes},
 
 		{"class",
 				{"name",	"commands",	NULL},
 				{"",		"",		NULL},
-				{DT_CHARPTR,	DT_CHARPTR},
+				{DT_NOSPACES,	DT_CHARPTR},
 				InitClasses, DoClass, DoneClassesAndTypes},
-
+	
 		{NULL,
 				{NULL},
 				{NULL},
@@ -832,14 +935,12 @@ void ServerConfig::Read(bool bail, User* user)
 				NULL, NULL, NULL}
 	};
 
-	include_stack.clear();
-
 	/* Load and parse the config file, if there are any errors then explode */
 
 	/* Make a copy here so if it fails then we can carry on running with an unaffected config */
-	ConfigDataHash newconfig;
+	newconfig.clear();
 
-	if (this->LoadConf(newconfig, ServerInstance->ConfigFileName, errstr))
+	if (this->LoadConf(newconfig, ServerInstance->ConfigFileName, errstr, pass))
 	{
 		/* If we succeeded, set the ircd config to the new one */
 		this->config_data = newconfig;
@@ -853,29 +954,54 @@ void ServerConfig::Read(bool bail, User* user)
 	/* The stuff in here may throw CoreException, be sure we're in a position to catch it. */
 	try
 	{
-		/* Check we dont have more than one of singular tags, or any of them missing
-		 */
-		for (int Index = 0; Once[Index]; Index++)
-			if (!CheckOnce(Once[Index]))
-				return;
-
 		/* Read the values of all the tags which occur once or not at all, and call their callbacks.
 		 */
 		for (int Index = 0; Values[Index].tag; Index++)
 		{
 			char item[MAXBUF];
 			int dt = Values[Index].datatype;
-			bool allow_newlines =  ((dt & DT_ALLOW_NEWLINE) > 0);
+			bool allow_newlines = ((dt & DT_ALLOW_NEWLINE) > 0);
+			bool allow_wild = ((dt & DT_ALLOW_WILD) > 0);
 			dt &= ~DT_ALLOW_NEWLINE;
+			dt &= ~DT_ALLOW_WILD;
 
 			ConfValue(this->config_data, Values[Index].tag, Values[Index].value, Values[Index].default_value, 0, item, MAXBUF, allow_newlines);
 			ValueItem vi(item);
-
+			
 			if (!Values[Index].validation_function(this, Values[Index].tag, Values[Index].value, vi))
 				throw CoreException("One or more values in your configuration file failed to validate. Please see your ircd.log for more information.");
-
+	
 			switch (Values[Index].datatype)
 			{
+				case DT_NOSPACES:
+				{
+					ValueContainerChar* vcc = (ValueContainerChar*)Values[Index].val;
+					this->ValidateNoSpaces(vi.GetString(), Values[Index].tag, Values[Index].value);
+					vcc->Set(vi.GetString(), strlen(vi.GetString()) + 1);
+				}
+				break;
+				case DT_HOSTNAME:
+				{
+					ValueContainerChar* vcc = (ValueContainerChar*)Values[Index].val;
+					this->ValidateHostname(vi.GetString(), Values[Index].tag, Values[Index].value);
+					vcc->Set(vi.GetString(), strlen(vi.GetString()) + 1);
+				}
+				break;
+				case DT_IPADDRESS:
+				{
+					ValueContainerChar* vcc = (ValueContainerChar*)Values[Index].val;
+					this->ValidateIP(vi.GetString(), Values[Index].tag, Values[Index].value, allow_wild);
+					vcc->Set(vi.GetString(), strlen(vi.GetString()) + 1);
+				}
+				break;
+				case DT_CHANNEL:
+				{
+					ValueContainerChar* vcc = (ValueContainerChar*)Values[Index].val;
+					if (*(vi.GetString()) && !ServerInstance->IsChannel(vi.GetString()))
+						throw CoreException("The value of <"+std::string(Values[Index].tag)+":"+Values[Index].value+"> is not a valid channel name");
+					vcc->Set(vi.GetString(), strlen(vi.GetString()) + 1);
+				}
+				break;
 				case DT_CHARPTR:
 				{
 					ValueContainerChar* vcc = (ValueContainerChar*)Values[Index].val;
@@ -901,7 +1027,6 @@ void ServerConfig::Read(bool bail, User* user)
 					/* You don't want to know what happens if someones bad code sends us here. */
 				break;
 			}
-
 			/* We're done with this now */
 			delete Values[Index].val;
 		}
@@ -923,10 +1048,53 @@ void ServerConfig::Read(bool bail, User* user)
 				{
 					int dt = MultiValues[Index].datatype[valuenum];
 					bool allow_newlines =  ((dt & DT_ALLOW_NEWLINE) > 0);
+					bool allow_wild = ((dt & DT_ALLOW_WILD) > 0);
 					dt &= ~DT_ALLOW_NEWLINE;
+					dt &= ~DT_ALLOW_WILD;
 
 					switch (dt)
 					{
+						case DT_NOSPACES:
+						{
+							char item[MAXBUF];
+							if (ConfValue(this->config_data, MultiValues[Index].tag, MultiValues[Index].items[valuenum], MultiValues[Index].items_default[valuenum], tagnum, item, MAXBUF, allow_newlines))
+								vl.push_back(ValueItem(item));
+							else
+								vl.push_back(ValueItem(""));
+							this->ValidateNoSpaces(vl[vl.size()-1].GetString(), MultiValues[Index].tag, MultiValues[Index].items[valuenum]);
+						}
+						break;
+						case DT_HOSTNAME:
+						{
+							char item[MAXBUF];
+							if (ConfValue(this->config_data, MultiValues[Index].tag, MultiValues[Index].items[valuenum], MultiValues[Index].items_default[valuenum], tagnum, item, MAXBUF, allow_newlines))
+								vl.push_back(ValueItem(item));
+							else
+								vl.push_back(ValueItem(""));
+							this->ValidateHostname(vl[vl.size()-1].GetString(), MultiValues[Index].tag, MultiValues[Index].items[valuenum]);
+						}
+						break;
+						case DT_IPADDRESS:
+						{
+							char item[MAXBUF];
+							if (ConfValue(this->config_data, MultiValues[Index].tag, MultiValues[Index].items[valuenum], MultiValues[Index].items_default[valuenum], tagnum, item, MAXBUF, allow_newlines))
+								vl.push_back(ValueItem(item));
+							else
+								vl.push_back(ValueItem(""));
+							this->ValidateIP(vl[vl.size()-1].GetString(), MultiValues[Index].tag, MultiValues[Index].items[valuenum], allow_wild);
+						}
+						break;
+						case DT_CHANNEL:
+						{
+							char item[MAXBUF];
+							if (ConfValue(this->config_data, MultiValues[Index].tag, MultiValues[Index].items[valuenum], MultiValues[Index].items_default[valuenum], tagnum, item, MAXBUF, allow_newlines))
+								vl.push_back(ValueItem(item));
+							else
+								vl.push_back(ValueItem(""));
+							if (!ServerInstance->IsChannel(vl[vl.size()-1].GetString()))
+								throw CoreException("The value of <"+std::string(MultiValues[Index].tag)+":"+MultiValues[Index].items[valuenum]+"> number "+ConvToStr(tagnum + 1)+" is not a valid channel name");
+						}
+						break;
 						case DT_CHARPTR:
 						{
 							char item[MAXBUF];
@@ -956,11 +1124,9 @@ void ServerConfig::Read(bool bail, User* user)
 						break;
 					}
 				}
-
-				MultiValues[Index].validation_function(this, MultiValues[Index].tag, (char**)MultiValues[Index].items, vl, MultiValues[Index].datatype);
+					MultiValues[Index].validation_function(this, MultiValues[Index].tag, (char**)MultiValues[Index].items, vl, MultiValues[Index].datatype);
 			}
-
-			MultiValues[Index].finish_function(this, MultiValues[Index].tag);
+				MultiValues[Index].finish_function(this, MultiValues[Index].tag);
 		}
 
 	}
@@ -971,6 +1137,44 @@ void ServerConfig::Read(bool bail, User* user)
 		return;
 	}
 
+	/** XXX END PASS **/
+	ServerInstance->Log(DEBUG,"End config pass %d", pass);
+
+	if (pass == 0)
+	{
+		/* FIRST PASS: Set up commands, load modules.
+		 * We cannot gaurantee that all config is correct
+		 * at this point
+		 */
+
+		if (pass == 0)
+		{
+			ServerInstance->Log(DEBUG, "Downloading configuration");
+
+			TotalDownloaded = 0;
+			FileErrors = 0;
+		}
+
+		if (!ServerInstance->Res)
+			ServerInstance->Res = new DNS(ServerInstance);
+	        /** Note: This is safe, the method checks for user == NULL */
+	        ServerInstance->Parser->SetupCommandTable(user);
+		ServerInstance->Modules->LoadAll();
+	}
+	else
+	{
+		/* SECOND PASS: Call modules to read configs, finalize
+		 * stuff. Check that we have at least the required number
+		 * of whichever items. This is no longer done first.
+		 */
+		ConfigReader* n = new ConfigReader(ServerInstance);
+		FOREACH_MOD(I_OnReadConfig,OnReadConfig(this, n));
+
+		for (int Index = 0; Once[Index]; Index++)
+			if (!CheckOnce(Once[Index]))
+				return;
+	}
+
 	// write once here, to try it out and make sure its ok
 	ServerInstance->WritePID(this->PID);
 
@@ -994,54 +1198,61 @@ void ServerConfig::Read(bool bail, User* user)
 				user->WriteServ("NOTICE %s :*** %d.   IP: %s     Port: %lu", user->nick, j, i->first.empty() ? "<all>" : i->first.c_str(), (unsigned long)i->second);
 			}
 		}
+	}
 
-		if (!removed_modules.empty())
+	if (!removed_modules.empty())
+	{
+		for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
 		{
-			for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
+			if (ServerInstance->Modules->Unload(removing->c_str()))
 			{
-				if (ServerInstance->Modules->Unload(removing->c_str()))
-				{
-					ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
-
-					if (user)
-						user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
-
-					rem++;
-				}
-				else
-				{
-					if (user)
-						user->WriteServ("972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ServerInstance->Modules->LastError());
-				}
+				ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
+				if (user)
+					user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
+				rem++;
+			}
+			else
+			{
+				if (user)
+					user->WriteServ("972 %s %s :%s",user->nick, removing->c_str(), ServerInstance->Modules->LastError().c_str());
 			}
 		}
+	}
 
-		if (!added_modules.empty())
+	if (!added_modules.empty())
+	{
+		for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
 		{
-			for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
+			/* Skip over modules that are aleready loaded for some reason */
+			if (ServerInstance->Modules->Find(*adding))
+				continue;
+
+			if (bail)
+				printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n", adding->c_str());
+
+			if (ServerInstance->Modules->Load(adding->c_str()))
 			{
-				if (ServerInstance->Modules->Load(adding->c_str()))
-				{
-					ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
+				ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
+				if (user)
+					user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
 
-					if (user)
-						user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
+				add++;
+			}
+			else
+			{
+				if (user)
+					user->WriteServ("974 %s %s :%s",user->nick, adding->c_str(), ServerInstance->Modules->LastError().c_str());
 
-					add++;
-				}
-				else
+				if (bail)
 				{
-					if (user)
-						user->WriteServ("974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ServerInstance->Modules->LastError());
+					printf_c("\n[\033[1;31m*\033[0m] %s\n\n", ServerInstance->Modules->LastError().c_str());
+					ServerInstance->Exit(EXIT_STATUS_MODULE);
 				}
 			}
 		}
-
-		ServerInstance->Log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),(unsigned long)add,(unsigned long)added_modules.size());
 	}
 
-	/** Note: This is safe, the method checks for user == NULL */
-	ServerInstance->Parser->SetupCommandTable(user);
+	ServerInstance->Log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),(unsigned long)add,(unsigned long)added_modules.size());
 
 	if (user)
 		user->WriteServ("NOTICE %s :*** Successfully rehashed server.", user->nick);
@@ -1049,10 +1260,71 @@ void ServerConfig::Read(bool bail, User* user)
 		ServerInstance->WriteOpers("*** Successfully rehashed server.");
 }
 
-bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::ostringstream &errorstream)
+/* XXX: This can and will block! */
+void ServerConfig::DoDownloads()
+{
+	ServerInstance->Log(DEBUG,"In DoDownloads()");
+
+	/* Reads all local files into the IncludedFiles map, then initiates sockets for the remote ones */
+	for (std::map<std::string, std::istream*>::iterator x = IncludedFiles.begin(); x != IncludedFiles.end(); ++x)
+	{
+		if (CompletedFiles.find(x->first) != CompletedFiles.end())
+			continue;
+
+		ServerInstance->Log(DEBUG,"StartDownloads File: %s", x->first.c_str());
+
+		std::string file = x->first;
+		if ((file[0] == '/') || (file.substr(0, 7) == "file://"))
+		{
+			/* For file:// schema files, we use std::ifstream which is a derivative of std::istream.
+			 * For all other file schemas, we use a std::stringstream.
+			 */
+
+			/* Add our own ifstream */
+			std::ifstream* conf = new std::ifstream(file.c_str());
+			if (!conf->fail())
+			{
+				ServerInstance->Log(DEBUG,"file:// schema file %s loaded OK", file.c_str());
+				delete x->second;
+				x->second = conf;
+			}
+			else
+			{
+				delete x->second;
+				x->second = NULL;
+				FileErrors++;
+			}
+			TotalDownloaded++;
+		}
+		else
+		{
+			/* Modules handle these */
+			ServerInstance->Log(DEBUG,"Module-handled schema for %s", x->first.c_str());
+
+			/* For now, error it */
+			int MOD_RESULT = 0;
+			FOREACH_RESULT(I_OnDownloadFile, OnDownloadFile(file, x->second));
+			if (MOD_RESULT == 0)
+			{
+				/* No module claimed this file */
+				TotalDownloaded++;
+				FileErrors++;
+				delete x->second;
+				x->second = NULL;
+			}
+			else
+			{
+				/* Search new file here for more includes to parse */
+			}
+		}
+		CompletedFiles[x->first] = true;
+	}
+}
+
+bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::ostringstream &errorstream, int pass, std::istream *scan_for_includes_only)
 {
-	std::ifstream conf(filename);
 	std::string line;
+	std::istream* conf = NULL;
 	char ch;
 	long linenumber;
 	bool in_tag;
@@ -1065,30 +1337,63 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 	in_quote = false;
 	in_comment = false;
 
-	/* Check if the file open failed first */
-	if (!conf)
+	if (scan_for_includes_only)
 	{
-		errorstream << "LoadConf: Couldn't open config file: " << filename << std::endl;
-		return false;
+		ServerInstance->Log(DEBUG,"scan_for_includes_only set");
+		conf = scan_for_includes_only;
 	}
 
-	/* Fix the chmod of the file to restrict it to the current user and group */
-	chmod(filename,0600);
-
-	for (unsigned int t = 0; t < include_stack.size(); t++)
+	if (std::string(filename) == CONFIG_FILE)
 	{
-		if (std::string(filename) == include_stack[t])
+		if (!scan_for_includes_only)
 		{
-			errorstream << "File " << filename << " is included recursively (looped inclusion)." << std::endl;
-			return false;
+			conf = new std::ifstream(filename);
+			if (conf->fail())
+			{
+				errorstream << "File " << filename << " could not be opened." << std::endl;
+				return false;
+			}
+		}
+	}
+	else
+	{
+		std::map<std::string, std::istream*>::iterator x = IncludedFiles.find(filename);
+		if (x == IncludedFiles.end())
+		{
+			if (pass == 0)
+			{
+				ServerInstance->Log(DEBUG,"Push include file %s onto map", filename);
+				/* First pass, we insert the file into a map, and just return true */
+				IncludedFiles.insert(std::make_pair(filename,new std::stringstream));
+				return true;
+			}
+			else
+			{
+				/* Second pass, look for the file in the map */
+				ServerInstance->Log(DEBUG,"We are in the second pass, and %s is not in the map!", filename);
+				errorstream << "File " << filename << " could not be opened." << std::endl;
+				return false;
+			}
+		}
+		else
+		{
+			if (!scan_for_includes_only)
+			{
+				if (x->second)
+					conf = IncludedFiles.find(filename)->second;
+				else
+				{
+					errorstream << "File " << filename << " could not be opened." << std::endl;
+					return false;
+				}
+			}
 		}
 	}
 
-	/* It's not already included, add it to the list of files we've loaded */
-	include_stack.push_back(filename);
+	ServerInstance->Log(DEBUG,"Start to read conf %s %08lx", filename, conf);
 
 	/* Start reading characters... */
-	while (conf.get(ch))
+	while (conf->get(ch))
 	{
 
 		/*
@@ -1102,6 +1407,8 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 		if ((character_count++ < 2) && (ch == '\xFF' || ch == '\xFE'))
 		{
 			errorstream << "File " << filename << " cannot be read, as it is encoded in braindead UTF-16. Save your file as plain ASCII!" << std::endl;
+			if (!scan_for_includes_only)
+				delete conf;
 			return false;
 		}
 
@@ -1147,7 +1454,7 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 		{
 			line += ch;
 			char real_character;
-			if (conf.get(real_character))
+			if (conf->get(real_character))
 			{
 				if (real_character == 'n')
 					real_character = '\n';
@@ -1157,6 +1464,8 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 			else
 			{
 				errorstream << "End of file after a \\, what did you want to escape?: " << filename << ":" << linenumber << std::endl;
+				if (!scan_for_includes_only)
+					delete conf;
 				return false;
 			}
 		}
@@ -1171,6 +1480,8 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 				if (!in_quote)
 				{
 					errorstream << "Got another opening < when the first one wasn't closed: " << filename << ":" << linenumber << std::endl;
+					if (!scan_for_includes_only)
+						delete conf;
 					return false;
 				}
 			}
@@ -1179,6 +1490,8 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 				if (in_quote)
 				{
 					errorstream << "We're in a quote but outside a tag, interesting. " << filename << ":" << linenumber << std::endl;
+					if (!scan_for_includes_only)
+						delete conf;
 					return false;
 				}
 				else
@@ -1229,14 +1542,20 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 					 * LoadConf() and load the included config into the same ConfigDataHash
 					 */
 
-					if (!this->ParseLine(target, line, linenumber, errorstream))
+					if (!this->ParseLine(target, line, linenumber, errorstream, pass, scan_for_includes_only))
+					{
+						if (!scan_for_includes_only)
+							delete conf;
 						return false;
+					}
 
 					line.clear();
 				}
 				else
 				{
 					errorstream << "Got a closing > when we weren't inside a tag: " << filename << ":" << linenumber << std::endl;
+					if (!scan_for_includes_only)
+						delete conf;
 					return false;
 				}
 			}
@@ -1250,15 +1569,17 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
 			is a newline missing from the end of the file: " << filename << ":" << linenumber << std::endl;
 	}
 
+	if (!scan_for_includes_only)
+		delete conf;
 	return true;
 }
 
-bool ServerConfig::LoadConf(ConfigDataHash &target, const std::string &filename, std::ostringstream &errorstream)
+bool ServerConfig::LoadConf(ConfigDataHash &target, const std::string &filename, std::ostringstream &errorstream, int pass, std::istream* scan_for_includs_only)
 {
-	return this->LoadConf(target, filename.c_str(), errorstream);
+	return this->LoadConf(target, filename.c_str(), errorstream, pass, scan_for_includs_only);
 }
 
-bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &linenumber, std::ostringstream &errorstream)
+bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &linenumber, std::ostringstream &errorstream, int pass, std::istream* scan_for_includes_only)
 {
 	std::string tagname;
 	std::string current_key;
@@ -1348,7 +1669,8 @@ bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &li
 					else
 					{
 						/* Leaving quotes, we have the value */
-						results.push_back(KeyVal(current_key, current_value));
+						if (!scan_for_includes_only)
+							results.push_back(KeyVal(current_key, current_value));
 
 						// std::cout << "<" << tagname << ":" << current_key << "> " << current_value << std::endl;
 
@@ -1356,8 +1678,8 @@ bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &li
 						got_key = false;
 
 						if ((tagname == "include") && (current_key == "file"))
-						{
-							if (!this->DoInclude(target, current_value, errorstream))
+						{	
+							if (!this->DoInclude(target, current_value, errorstream, pass, scan_for_includes_only))
 								return false;
 						}
 
@@ -1377,12 +1699,13 @@ bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &li
 	}
 
 	/* Finished parsing the tag, add it to the config hash */
-	target.insert(std::pair<std::string, KeyValList > (tagname, results));
+	if (!scan_for_includes_only)
+		target.insert(std::pair<std::string, KeyValList > (tagname, results));
 
 	return true;
 }
 
-bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream)
+bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream, int pass, std::istream* scan_for_includes_only)
 {
 	std::string confpath;
 	std::string newfile;
@@ -1391,15 +1714,10 @@ bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, st
 	confpath = ServerInstance->ConfigFileName;
 	newfile = file;
 
-	for (std::string::iterator c = newfile.begin(); c != newfile.end(); c++)
-	{
-		if (*c == '\\')
-		{
-			*c = '/';
-		}
-	}
+	std::replace(newfile.begin(),newfile.end(),'\\','/');
+	std::replace(confpath.begin(),confpath.end(),'\\','/');
 
-	if (file[0] != '/')
+	if ((newfile[0] != '/') && (newfile.find("://") == std::string::npos))
 	{
 		if((pos = confpath.rfind("/")) != std::string::npos)
 		{
@@ -1408,12 +1726,12 @@ bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, st
 		}
 		else
 		{
-			errorstream << "Couldn't get config path from: " << confpath << std::endl;
+			errorstream << "Couldn't get config path from: " << ServerInstance->ConfigFileName << std::endl;
 			return false;
 		}
 	}
 
-	return LoadConf(target, newfile, errorstream);
+	return LoadConf(target, newfile, errorstream, pass, scan_for_includes_only);
 }
 
 bool ServerConfig::ConfValue(ConfigDataHash &target, const char* tag, const char* var, int index, char* result, int length, bool allow_linefeeds)
@@ -1781,11 +2099,7 @@ InspIRCd* ServerConfig::GetInstance()
 
 std::string ServerConfig::GetSID()
 {
-	std::string OurSID;
-	OurSID += (char)((sid / 100) + 48);
-	OurSID += (char)((sid / 10) % 10 + 48);
-	OurSID += (char)(sid % 10 + 48);
-	return OurSID;
+	return sid;
 }
 
 ValueItem::ValueItem(int value)
@@ -1912,3 +2226,76 @@ bool DoneClassesAndTypes(ServerConfig*, const char*)
 	return true;
 }
 
+
+
+bool InitXLine(ServerConfig* conf, const char* tag)
+{
+	return true;
+}
+
+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();
+
+	ZLine* zl = new ZLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ipmask);
+	if (!conf->GetInstance()->XLines->AddLine(zl, NULL))
+		delete zl;
+
+	return true;
+}
+
+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();
+
+	QLine* ql = new QLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, nick);
+	if (!conf->GetInstance()->XLines->AddLine(ql, NULL))
+		delete ql;
+
+	return true;
+}
+
+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();
+
+	XLineManager* xlm = conf->GetInstance()->XLines;
+
+	IdentHostPair ih = xlm->IdentSplit(host);
+
+	KLine* kl = new KLine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
+	if (!xlm->AddLine(kl, NULL))
+		delete kl;
+	return true;
+}
+
+bool DoELine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+{
+	const char* reason = values[0].GetString();
+	const char* host = values[1].GetString();
+
+	XLineManager* xlm = conf->GetInstance()->XLines;
+
+	IdentHostPair ih = xlm->IdentSplit(host);
+
+	ELine* el = new ELine(conf->GetInstance(), conf->GetInstance()->Time(), 0, "<Config>", reason, ih.first.c_str(), ih.second.c_str());
+	if (!xlm->AddLine(el, NULL))
+		delete el;
+	return true;
+}
+
+// this should probably be moved to configreader, but atm it relies on CheckELines above.
+bool DoneELine(ServerConfig* conf, const char* tag)
+{
+	for (std::vector<User*>::const_iterator u2 = conf->GetInstance()->local_users.begin(); u2 != conf->GetInstance()->local_users.end(); u2++)
+	{
+		User* u = (User*)(*u2);
+		u->exempt = false;
+	}
+
+	conf->GetInstance()->XLines->CheckELines();
+	return true;
+}