X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Finspircd_io.cpp;h=f4ab7ce071ea360ac33e41101015453cc51b528d;hb=bf3b7b4696115c5f90b9c2a7ea966d0f9d3eb394;hp=9b554d3ef93ad5ad5e8a77757d4a034979dd7bc0;hpb=87cb6185e59d48d1904aa7555a425469a90f844f;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/inspircd_io.cpp b/src/inspircd_io.cpp
index 9b554d3ef..f4ab7ce07 100644
--- a/src/inspircd_io.cpp
+++ b/src/inspircd_io.cpp
@@ -5,7 +5,7 @@
  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
  *                       E-mail:
  *                <brain@chatspike.net>
- *           	  <Craig@chatspike.net>
+ *                <Craig@chatspike.net>
  *     
  * Written by Craig Edwards, Craig McLure, and others.
  * This program is free but copyrighted software; see
@@ -25,6 +25,7 @@ using namespace std;
 #include <sstream>
 #include <iostream>
 #include <fstream>
+#include "message.h"
 #include "inspircd.h"
 #include "inspircd_io.h"
 #include "inspstring.h"
@@ -41,6 +42,8 @@ extern int MODCOUNT;
 extern std::vector<Module*> modules;
 extern std::vector<ircd_module*> factory;
 
+std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
+
 ServerConfig::ServerConfig()
 {
 	this->ClearStack();
@@ -149,186 +152,64 @@ bool ServerConfig::CheckOnce(char* tag, bool bail, userrec* user)
 	return true;
 }
 
-typedef bool (*Validator)(const char*, const char*, void*);
-
-enum ConfigDataType { DT_NOTHING, DT_INTEGER, DT_CHARPTR, DT_BOOLEAN };
-
-struct InitialConfig {
-	char* tag;
-	char* value;
-	void* val;
-	ConfigDataType datatype;
-	Validator validate_function;
-};
-
 bool NoValidation(const char* tag, const char* value, void* data)
 {
 	log(DEBUG,"No validation for <%s:%s>",tag,value);
 	return true;
 }
 
-void ServerConfig::Read(bool bail, userrec* user)
+bool ValidateTempDir(const char* tag, const char* value, void* data)
 {
-	char debug[MAXBUF];
-
-	InitialConfig Values[] = {
-		{"options",	"softlimit",		&this->SoftLimit,		DT_INTEGER, NoValidation},
-		{"options",	"somaxconn",		&this->MaxConn,			DT_INTEGER, NoValidation},
-		{"server",	"name",			&this->ServerName,		DT_CHARPTR, NoValidation},
-		{"server",	"description",		&this->ServerDesc,		DT_CHARPTR, NoValidation},
-		{"server",	"network",		&this->Network,			DT_CHARPTR, NoValidation},
-		{"admin"	"name",			&this->AdminName,		DT_CHARPTR, NoValidation},
-		{"admin",	"email",		&this->AdminEmail,		DT_CHARPTR, NoValidation},
-		{"admin",	"nick",			&this->AdminNick,		DT_CHARPTR, NoValidation},
-		{"files",	"motd",			&this->motd,			DT_CHARPTR, NoValidation},
-		{"files",	"rules",		&this->rules,			DT_CHARPTR, NoValidation},
-		{"power",	"diepass",		&this->diepass,			DT_CHARPTR, NoValidation},	
-		{"power",	"pauseval",		&this->DieDelay,		DT_INTEGER, NoValidation},
-		{"power",	"restartpass",		&this->restartpass,		DT_CHARPTR, NoValidation},
-		{"options",	"prefixquit",		&this->PrefixQuit,		DT_CHARPTR, NoValidation},
-		{"die",		"value",		&this->DieValue,		DT_CHARPTR, NoValidation},
-		{"options",	"loglevel",		&debug,				DT_CHARPTR, NoValidation},
-		{"options",	"netbuffersize",	&this->NetBufferSize,		DT_INTEGER, NoValidation},
-		{"options",	"maxwho",		&this->MaxWhoResults,		DT_INTEGER, NoValidation},
-		{"options",	"allowhalfop",		&this->AllowHalfop,		DT_BOOLEAN, NoValidation},
-		{"dns",		"server",		&this->DNSServer,		DT_CHARPTR, NoValidation},
-		{"dns",		"timeout",		&this->dns_timeout,		DT_INTEGER, NoValidation},
-		{"options",	"moduledir",		&this->ModPath,			DT_CHARPTR, NoValidation},
-		{"disabled",	"commands",		&this->DisabledCommands,	DT_CHARPTR, NoValidation},
-		{"options",	"operonlystats",	&this->OperOnlyStats,		DT_CHARPTR, NoValidation},
-		{"options",	"customversion",	&this->CustomVersion,		DT_CHARPTR, NoValidation},
-		{"options",	"hidesplits",		&this->HideSplits,		DT_BOOLEAN, NoValidation},
-		{"options",	"hidebans",		&this->HideBans,		DT_BOOLEAN, NoValidation},
-		{"options",	"hidewhois",		&this->HideWhoisServer,		DT_CHARPTR, NoValidation},
-		{"options",	"tempdir",		&this->TempDir,			DT_CHARPTR, NoValidation},
-		{NULL}
-	};
-
-	/* XXX - this needs a rework someday, BAD. */
-	char timeout[MAXBUF],flood[MAXBUF],pfreq[MAXBUF],thold[MAXBUF],sqmax[MAXBUF],rqmax[MAXBUF],SLIMT[MAXBUF];
-	char localmax[MAXBUF],globalmax[MAXBUF],ServName[MAXBUF];
-
-	ConnectClass c;
-	std::stringstream errstr;
-	
-	include_stack.clear();
-
-	if (!LoadConf(CONFIG_FILE,&Config->config_f,&errstr))
-	{
-		errstr.seekg(0);
-		log(DEFAULT,"There were errors in your configuration:\n%s",errstr.str().c_str());
-
-		if (bail)
-		{
-			printf("There were errors in your configuration:\n%s",errstr.str().c_str());
-			Exit(0);
-		}
-		else
-		{
-			char dataline[1024];
-
-			if (user)
-			{
-				WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
-				while (!errstr.eof())
-				{
-					errstr.getline(dataline,1024);
-					WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
-				}
-			}
-			else
-			{
-				WriteOpers("There were errors in the configuration file:");
-				while (!errstr.eof())
-				{
-					errstr.getline(dataline,1024);
-					WriteOpers(dataline);
-				}
-			}
-
-			return;
-		}
-	}
-
-	/* Check we dont have more than one of singular tags
-	 */
-	if (!CheckOnce("server",bail,user) || !CheckOnce("admin",bail,user) || !CheckOnce("files",bail,user)
-		|| !CheckOnce("power",bail,user) || !CheckOnce("options",bail,user) || !CheckOnce("pid",bail,user))
-	{
-		return;
-	}
-
-	char* convert;
-	for (int Index = 0; Values[Index].datatype != DT_NOTHING; Index++)
-	{
-		void* val = Values[Index].val;
-
-		switch (Values[Index].datatype)
-		{
-			case DT_CHARPTR:
-				ConfValue((char*)Values[Index].tag,(char*)Values[Index].value,(char*) val,this->config_f);
-			break;
-
-			case DT_INTEGER:
-				convert = new char[MAXBUF];
-				ConfValue(Values[Index].tag,Values[Index].value,convert,this->config_f);
-				*val = atoi(convert);
-				delete[] convert;
-			break;
-
-			case DT_BOOLEAN:
-				convert = new char[MAXBUF];
-				ConfValue(Values[Index].tag,Values[Index].value,convert,this->config_f);
-				*val = ((*convert == tolower('y')) || (*convert == tolower('t')) || (*convert == '1'));
-				delete[] convert;
-			break;
-
-			case DT_NOTHING:
-			break;
-		}
-
-		Values[Index].validation_function(Values[Index].tag, Values[Index].value, Values[Index].val);
-	}
-
-	strlower(this->ServerName);
-
-	if (!*Config->TempDir)
-		strlcpy(Config->TempDir,"/tmp",1024);
-
-	if ((Config->MaxTargets < 0) || (Config->MaxTargets > 31))
+	char* x = (char*)data;
+	if (!*x)
+		strlcpy(x,"/tmp",1024);
+	return true;
+}
+ 
+bool ValidateMaxTargets(const char* tag, const char* value, void* data)
+{
+	int* x = (int*)data;
+	if ((*x < 0) || (*x > 31))
 	{
 		log(DEFAULT,"WARNING: <options:maxtargets> value is greater than 31 or less than 0, set to 20.");
-		Config->MaxTargets = 20;
+		*x = 20;
 	}
+	return true;
+}
 
-	if ((Config->SoftLimit < 1) || (Config->SoftLimit > MAXCLIENTS))
+bool ValidateSoftLimit(const char* tag, const char* value, void* data)
+{
+	int* x = (int*)data;	
+	if ((*x < 1) || (*x > MAXCLIENTS))
 	{
 		log(DEFAULT,"WARNING: <options:softlimit> value is greater than %d or less than 0, set to %d.",MAXCLIENTS,MAXCLIENTS);
-		Config->SoftLimit = MAXCLIENTS;
+		*x = MAXCLIENTS;
 	}
+	return true;
+}
 
-	Config->MaxConn = atoi(MCON);
-
-	if (Config->MaxConn > SOMAXCONN)
+bool ValidateMaxConn(const char* tag, const char* value, void* data)
+{
+	int* x = (int*)data;	
+	if (*x > SOMAXCONN)
 		log(DEFAULT,"WARNING: <options:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
+	if (!*x)
+		*x = SOMAXCONN;
+	return true;
+}
 
-	Config->NetBufferSize = atoi(NB);
-	Config->MaxWhoResults = atoi(MW);
-	Config->dns_timeout = atoi(DNT);
-
-	if (!strchr(Config->ServerName,'.'))
-	{
-		log(DEFAULT,"WARNING: <server:name> '%s' is not a fully-qualified domain name. Changed to '%s%c'",Config->ServerName,Config->ServerName,'.');
-		charlcat(Config->ServerName,'.',MAXBUF);
-	}
-
-	if (!Config->dns_timeout)
-		Config->dns_timeout = 5;
-
-	if (!Config->MaxConn)
-		Config->MaxConn = SOMAXCONN;
+bool ValidateDnsTimeout(const char* tag, const char* value, void* data)
+{
+	int* x = (int*)data;
+	if (!*x)
+		*x = 5;
+	return true;
+}
 
-	if (!*Config->DNSServer)
+bool ValidateDnsServer(const char* tag, const char* value, void* data)
+{
+	char* x = (char*)data;
+	if (!*x)
 	{
 		// attempt to look up their nameserver from /etc/resolv.conf
 		log(DEFAULT,"WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf...");
@@ -343,7 +224,7 @@ void ServerConfig::Read(bool bail, userrec* user)
 				if ((nameserver == "nameserver") && (!found_server))
 				{
 					resolv >> nameserver;
-					strlcpy(Config->DNSServer,nameserver.c_str(),MAXBUF);
+					strlcpy(x,nameserver.c_str(),MAXBUF);
 					found_server = true;
 					log(DEFAULT,"<dns:server> set to '%s' as first resolver in /etc/resolv.conf.",nameserver.c_str());
 				}
@@ -352,35 +233,63 @@ void ServerConfig::Read(bool bail, userrec* user)
 			if (!found_server)
 			{
 				log(DEFAULT,"/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
-				strlcpy(Config->DNSServer,"127.0.0.1",MAXBUF);
+				strlcpy(x,"127.0.0.1",MAXBUF);
 			}
 		}
 		else
 		{
 			log(DEFAULT,"/etc/resolv.conf can't be opened! Defaulting to nameserver '127.0.0.1'!");
-			strlcpy(Config->DNSServer,"127.0.0.1",MAXBUF);
+			strlcpy(x,"127.0.0.1",MAXBUF);
 		}
 	}
+	return true;
+}
 
-	if (!*Config->ModPath)
-		strlcpy(Config->ModPath,MOD_PATH,MAXBUF);
+bool ValidateModPath(const char* tag, const char* value, void* data)
+{
+	char* x = (char*)data;	
+	if (!*x)
+		strlcpy(x,MOD_PATH,MAXBUF);
+	return true;
+}
 
-	Config->AllowHalfop = ((!strcasecmp(AH,"true")) || (!strcasecmp(AH,"1")) || (!strcasecmp(AH,"yes")));
 
+bool ValidateServerName(const char* tag, const char* value, void* data)
+{
+	char* x = (char*)data;
+	if (!strchr(x,'.'))
+	{
+		log(DEFAULT,"WARNING: <server:name> '%s' is not a fully-qualified domain name. Changed to '%s%c'",x,x,'.');
+		charlcat(x,'.',MAXBUF);
+	}
+	//strlower(x);
+	return true;
+}
+
+bool ValidateNetBufferSize(const char* tag, const char* value, void* data)
+{
 	if ((!Config->NetBufferSize) || (Config->NetBufferSize > 65535) || (Config->NetBufferSize < 1024))
 	{
 		log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
 		Config->NetBufferSize = 10240;
 	}
+	return true;
+}
 
+bool ValidateMaxWho(const char* tag, const char* value, void* data)
+{
 	if ((!Config->MaxWhoResults) || (Config->MaxWhoResults > 65535) || (Config->MaxWhoResults < 1))
 	{
 		log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
 		Config->MaxWhoResults = 128;
 	}
+	return true;
+}
 
+bool ValidateLogLevel(const char* tag, const char* value, void* data)
+{
+	const char* dbg = (const char*)data;
 	Config->LogLevel = DEFAULT;
-
 	if (!strcmp(dbg,"debug"))
 	{
 		Config->LogLevel = DEBUG;
@@ -394,178 +303,456 @@ void ServerConfig::Read(bool bail, userrec* user)
 		Config->LogLevel = SPARSE;
 	else if (!strcmp(dbg,"none"))
 		Config->LogLevel = NONE;
+	return true;
+}
 
+bool ValidateMotd(const char* tag, const char* value, void* data)
+{
 	readfile(Config->MOTD,Config->motd);
-	log(DEFAULT,"Reading message of the day...");
+	return true;
+}
+
+bool ValidateRules(const char* tag, const char* value, void* data)
+{
 	readfile(Config->RULES,Config->rules);
+	return true;
+}
+
+/* Callback called before processing the first <connect> tag
+ */
+bool InitConnect(const char* tag)
+{
 	log(DEFAULT,"Reading connect classes...");
-	Classes.clear();
+	Config->Classes.clear();
+	return true;
+}
 
-	for (int i = 0; i < ConfValueEnum("connect",&Config->config_f); i++)
+/* Callback called to process a single <connect> tag
+ */
+bool DoConnect(const char* tag, char** entries, void** values, int* types)
+{
+	ConnectClass c;
+	char* allow = (char*)values[0]; /* Yeah, there are a lot of values. Live with it. */
+	char* deny = (char*)values[1];
+	char* password = (char*)values[2];
+	int* timeout = (int*)values[3];
+	int* pingfreq = (int*)values[4];
+	int* flood = (int*)values[5];
+	int* threshold = (int*)values[6];
+	int* sendq = (int*)values[7];
+	int* recvq = (int*)values[8];
+	int* localmax = (int*)values[9];
+	int* globalmax = (int*)values[10];
+
+	if (*allow)
 	{
-		*Value = 0;
-		ConfValue("connect","allow",i,Value,&Config->config_f);
-		ConfValue("connect","timeout",i,timeout,&Config->config_f);
-		ConfValue("connect","flood",i,flood,&Config->config_f);
-		ConfValue("connect","pingfreq",i,pfreq,&Config->config_f);
-		ConfValue("connect","threshold",i,thold,&Config->config_f);
-		ConfValue("connect","sendq",i,sqmax,&Config->config_f);
-		ConfValue("connect","recvq",i,rqmax,&Config->config_f);
-		ConfValue("connect","localmax",i,localmax,&Config->config_f);
-		ConfValue("connect","globalmax",i,globalmax,&Config->config_f);
-
-		if (*Value)
-		{
-			c.host = Value;
-			c.type = CC_ALLOW;
-			strlcpy(Value,"",MAXBUF);
-			ConfValue("connect","password",i,Value,&Config->config_f);
-			c.pass = Value;
-			c.registration_timeout = 90; // default is 2 minutes
-			c.pingtime = 120;
-			c.flood = atoi(flood);
-			c.threshold = 5;
-			c.sendqmax = 262144; // 256k
-			c.recvqmax = 4096;   // 4k
+		c.host = allow;
+		c.type = CC_ALLOW;
+		c.pass = password;
+		c.registration_timeout = *timeout;
+		c.pingtime = *pingfreq;
+		c.flood = *flood;
+		c.threshold = *threshold;
+		c.sendqmax = *sendq;
+		c.recvqmax = *recvq;
+		c.maxlocal = *localmax;
+		c.maxglobal = *globalmax;
+
+
+		if (c.maxlocal == 0)
 			c.maxlocal = 3;
+		if (c.maxglobal == 0)
 			c.maxglobal = 3;
+		if (c.threshold == 0)
+		{
+			c.threshold = 1;
+			c.flood = 999;
+			log(DEFAULT,"Warning: Connect allow line '%s' has no flood/threshold settings. Setting this tag to 999 lines in 1 second.",c.host.c_str());
+		}
+		if (c.sendqmax == 0)
+			c.sendqmax = 262114;
+		if (c.recvqmax == 0)
+			c.recvqmax = 4096;
+		if (c.registration_timeout == 0)
+			c.registration_timeout = 90;
+		if (c.pingtime == 0)
+			c.pingtime = 120;
+		Config->Classes.push_back(c);
+	}
+	else
+	{
+		c.host = deny;
+		c.type = CC_DENY;
+		Config->Classes.push_back(c);
+		log(DEBUG,"Read connect class type DENY, host=%s",deny);
+	}
 
-			if (atoi(localmax)>0)
-			{
-				c.maxlocal = atoi(localmax);
-			}
+	return true;
+}
 
-			if (atoi(globalmax)>0)
-			{
-				c.maxglobal = atoi(globalmax);
-			}
+/* Callback called when there are no more <connect> tags
+ */
+bool DoneConnect(const char* tag)
+{
+	log(DEBUG,"DoneConnect called for tag: %s",tag);
+	return true;
+}
 
-			if (atoi(thold)>0)
-			{
-				c.threshold = atoi(thold);
-			}
-			else
-			{
-				c.threshold = 1;
-				c.flood = 999;
-				log(DEFAULT,"Warning: Connect allow line '%s' has no flood/threshold settings. Setting this tag to 999 lines in 1 second.",c.host.c_str());
-			}
+/* Callback called before processing the first <uline> tag
+ */
+bool InitULine(const char* tag)
+{
+	Config->ulines.clear();
+	return true;
+}
 
-			if (atoi(sqmax)>0)
-			{
-				c.sendqmax = atoi(sqmax);
-			}
-			if (atoi(rqmax)>0)
-			{
-				c.recvqmax = atoi(rqmax);
-			}
-			if (atoi(timeout)>0)
-			{
-				c.registration_timeout = atoi(timeout);
-			}
-			if (atoi(pfreq)>0)
-			{
-				c.pingtime = atoi(pfreq);
-			}
+/* Callback called to process a single <uline> tag
+ */
+bool DoULine(const char* tag, char** entries, void** values, int* types)
+{
+	char* server = (char*)values[0];
+	log(DEBUG,"Read ULINE '%s'",server);
+	Config->ulines.push_back(server);
+	return true;
+}
 
-			Classes.push_back(c);
-		}
-		else
-		{
-			ConfValue("connect","deny",i,Value,&Config->config_f);
-			c.host = Value;
-			c.type = CC_DENY;
-			Classes.push_back(c);
-			log(DEBUG,"Read connect class type DENY, host=%s",c.host.c_str());
-		}
+/* Callback called when there are no more <uline> tags
+ */
+bool DoneULine(const char* tag)
+{
+	return true;
+}
+
+/* Callback called before processing the first <module> tag
+ */
+bool InitModule(const char* tag)
+{
+	old_module_names.clear();
+	new_module_names.clear();
+	added_modules.clear();
+	removed_modules.clear();
+	for (std::vector<std::string>::iterator t = Config->module_names.begin(); t != Config->module_names.end(); t++)
+	{
+		old_module_names.push_back(*t);
 	}
+	return true;
+}
 
-	Config->ulines.clear();
+/* Callback called to process a single <module> tag
+ */
+bool DoModule(const char* tag, char** entries, void** values, int* types)
+{
+	char* modname = (char*)values[0];
+	new_module_names.push_back(modname);
+	return true;
+}
+
+/* Callback called when there are no more <module> tags
+ */
+bool DoneModule(const char* tag)
+{
+	// now create a list of new modules that are due to be loaded
+	// and a seperate list of modules which are due to be unloaded
+	for (std::vector<std::string>::iterator _new = new_module_names.begin(); _new != new_module_names.end(); _new++)
+	{
+		bool added = true;
 
-	for (int i = 0; i < ConfValueEnum("uline",&Config->config_f); i++)
-	{   
-		ConfValue("uline","server",i,ServName,&Config->config_f);
+		for (std::vector<std::string>::iterator old = old_module_names.begin(); old != old_module_names.end(); old++)
 		{
-			log(DEBUG,"Read ULINE '%s'",ServName);
-			Config->ulines.push_back(ServName);
+			if (*old == *_new)
+				added = false;
 		}
-	}
 
-	maxbans.clear();
-	char CM1[MAXBUF],CM2[MAXBUF];
+		if (added)
+			added_modules.push_back(*_new);
+	}
 
-	for (int count = 0; count < Config->ConfValueEnum("banlist",&Config->config_f); count++)
+	for (std::vector<std::string>::iterator oldm = old_module_names.begin(); oldm != old_module_names.end(); oldm++)
 	{
-		Config->ConfValue("banlist","chan",count,CM1,&Config->config_f);
-		Config->ConfValue("banlist","limit",count,CM2,&Config->config_f);
-		maxbans[CM1] = atoi(CM2);
+		bool removed = true;
+		for (std::vector<std::string>::iterator newm = new_module_names.begin(); newm != new_module_names.end(); newm++)
+		{
+			if (*newm == *oldm)
+				removed = false;
+		}
+
+		if (removed)
+			removed_modules.push_back(*oldm);
 	}
+	return true;
+}
 
-	ReadClassesAndTypes();
-	log(DEFAULT,"Reading K lines,Q lines and Z lines from config...");
-	read_xline_defaults();
-	log(DEFAULT,"Applying K lines, Q lines and Z lines...");
-	apply_lines(APPLY_ALL);
+/* Callback called before processing the first <banlist> tag
+ */
+bool InitMaxBans(const char* tag)
+{
+	Config->maxbans.clear();
+	return true;
+}
 
-	ConfValue("pid","file",0,Config->PID,&Config->config_f);
-	// write once here, to try it out and make sure its ok
-	WritePID(Config->PID);
+/* Callback called to process a single <banlist> tag
+ */
+bool DoMaxBans(const char* tag, char** entries, void** values, int* types)
+{
+	char* channel = (char*)values[0];
+	int* limit = (int*)values[1];
+	Config->maxbans[channel] = *limit;
+	return true;
+}
 
-	log(DEFAULT,"Done reading configuration file, InspIRCd is now starting.");
-	if (!bail)
-	{
-		log(DEFAULT,"Adding and removing modules due to rehash...");
+/* Callback called when there are no more <banlist> tags.
+ */
+bool DoneMaxBans(const char* tag)
+{
+	return true;
+}
+
+void ServerConfig::Read(bool bail, userrec* user)
+{
+	char debug[MAXBUF];		/* Temporary buffer for debugging value */
+	char dataline[1024];		/* Temporary buffer for error output */
+	char* convert;			/* Temporary buffer used for reading singular values into */
+	char* data[12];			/* Temporary buffers for reading multiple occurance tags into */
+	void* ptr[12];			/* Temporary pointers for passing to callbacks */
+	int r_i[12];			/* Temporary array for casting */
+	int rem = 0, add = 0;		/* Number of modules added, number of modules removed */
+	std::stringstream errstr;	/* String stream containing the error output */
+
+	/* These tags MUST occur and must ONLY occur once in the config file */
+	static char* Once[] = { "server", "admin", "files", "power", "options", "pid", NULL };
+
+	/* These tags can occur ONCE or not at all */
+	static InitialConfig Values[] = {
+		{"options",	"softlimit",		&this->SoftLimit,		DT_INTEGER, ValidateSoftLimit},
+		{"options",	"somaxconn",		&this->MaxConn,			DT_INTEGER, ValidateMaxConn},
+		{"server",	"name",			&this->ServerName,		DT_CHARPTR, ValidateServerName},
+		{"server",	"description",		&this->ServerDesc,		DT_CHARPTR, NoValidation},
+		{"server",	"network",		&this->Network,			DT_CHARPTR, NoValidation},
+		{"admin",	"name",			&this->AdminName,		DT_CHARPTR, NoValidation},
+		{"admin",	"email",		&this->AdminEmail,		DT_CHARPTR, NoValidation},
+		{"admin",	"nick",			&this->AdminNick,		DT_CHARPTR, NoValidation},
+		{"files",	"motd",			&this->motd,			DT_CHARPTR, ValidateMotd},
+		{"files",	"rules",		&this->rules,			DT_CHARPTR, ValidateRules},
+		{"power",	"diepass",		&this->diepass,			DT_CHARPTR, NoValidation},	
+		{"power",	"pauseval",		&this->DieDelay,		DT_INTEGER, NoValidation},
+		{"power",	"restartpass",		&this->restartpass,		DT_CHARPTR, NoValidation},
+		{"options",	"prefixquit",		&this->PrefixQuit,		DT_CHARPTR, NoValidation},
+		{"die",		"value",		&this->DieValue,		DT_CHARPTR, NoValidation},
+		{"options",	"loglevel",		&debug,				DT_CHARPTR, ValidateLogLevel},
+		{"options",	"netbuffersize",	&this->NetBufferSize,		DT_INTEGER, ValidateNetBufferSize},
+		{"options",	"maxwho",		&this->MaxWhoResults,		DT_INTEGER, ValidateMaxWho},
+		{"options",	"allowhalfop",		&this->AllowHalfop,		DT_BOOLEAN, NoValidation},
+		{"dns",		"server",		&this->DNSServer,		DT_CHARPTR, ValidateDnsServer},
+		{"dns",		"timeout",		&this->dns_timeout,		DT_INTEGER, ValidateDnsTimeout},
+		{"options",	"moduledir",		&this->ModPath,			DT_CHARPTR, ValidateModPath},
+		{"disabled",	"commands",		&this->DisabledCommands,	DT_CHARPTR, NoValidation},
+		{"options",	"operonlystats",	&this->OperOnlyStats,		DT_CHARPTR, NoValidation},
+		{"options",	"customversion",	&this->CustomVersion,		DT_CHARPTR, NoValidation},
+		{"options",	"hidesplits",		&this->HideSplits,		DT_BOOLEAN, NoValidation},
+		{"options",	"hidebans",		&this->HideBans,		DT_BOOLEAN, NoValidation},
+		{"options",	"hidewhois",		&this->HideWhoisServer,		DT_CHARPTR, NoValidation},
+		{"options",	"tempdir",		&this->TempDir,			DT_CHARPTR, ValidateTempDir},
+		{"pid",		"file",			&this->PID,			DT_CHARPTR, NoValidation},
+		{NULL}
+	};
+
+	/* These tags can occur multiple times, and therefore they have special code to read them
+	 * which is different to the code for reading the singular tags listed above.
+	 */
+	static MultiConfig MultiValues[] = {
+
+		{"connect",
+				{"allow",	"deny",		"password",	"timeout",	"pingfreq",	"flood",
+				"threshold",	"sendq",	"recvq",	"localmax",	"globalmax",	NULL},
+				{DT_CHARPTR,	DT_CHARPTR,	DT_CHARPTR,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,
+				 DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER,	DT_INTEGER},
+				InitConnect, DoConnect, DoneConnect},
+
+		{"uline",
+				{"server",	NULL},
+				{DT_CHARPTR},
+				InitULine,DoULine,DoneULine},
+
+		{"banlist",
+				{"chan",	"limit",	NULL},
+				{DT_CHARPTR,	DT_INTEGER},
+				InitMaxBans, DoMaxBans, DoneMaxBans},
+
+		{"module",
+				{"name",	NULL},
+				{DT_CHARPTR},
+				InitModule, DoModule, DoneModule},
+
+		{"badip",
+				{"reason",	"ipmask",	NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitXLine, DoZLine, DoneXLine},
+
+		{"badnick",
+				{"reason",	"nick",		NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitXLine, DoQLine, DoneXLine},
+
+		{"badhost",
+				{"reason",	"host",		NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitXLine, DoKLine, DoneXLine},
+
+		{"exception",
+				{"reason",	"host",		NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitXLine, DoELine, DoneXLine},
+
+		{"type",
+				{"name",	"classes",	NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitTypes, DoType, DoneClassesAndTypes},
+
+		{"class",
+				{"name",	"commands",	NULL},
+				{DT_CHARPTR,	DT_CHARPTR},
+				InitClasses, DoClass, DoneClassesAndTypes},
 
-		std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
+		{NULL}
+	};
+
+	include_stack.clear();
 
-		// store the old module names
-		for (std::vector<std::string>::iterator t = module_names.begin(); t != module_names.end(); t++)
+	/* Initially, load the config into memory, bail if there are errors
+	 */
+	if (!LoadConf(CONFIG_FILE,&Config->config_f,&errstr))
+	{
+		errstr.seekg(0);
+		log(DEFAULT,"There were errors in your configuration:\n%s",errstr.str().c_str());
+
+		if (bail)
 		{
-			old_module_names.push_back(*t);
+			printf("There were errors in your configuration:\n%s",errstr.str().c_str());
+			Exit(0);
 		}
-
-		// get the new module names
-		for (int count2 = 0; count2 < ConfValueEnum("module",&Config->config_f); count2++)
+		else
 		{
-			ConfValue("module","name",count2,Value,&Config->config_f);
-			new_module_names.push_back(Value);
+			if (user)
+			{
+				WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
+				while (!errstr.eof())
+				{
+					errstr.getline(dataline,1024);
+					WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
+				}
+			}
+			else
+			{
+				WriteOpers("There were errors in the configuration file:");
+				while (!errstr.eof())
+				{
+					errstr.getline(dataline,1024);
+					WriteOpers(dataline);
+				}
+			}
+
+			return;
 		}
+	}
 
-		// now create a list of new modules that are due to be loaded
-		// and a seperate list of modules which are due to be unloaded
-		for (std::vector<std::string>::iterator _new = new_module_names.begin(); _new != new_module_names.end(); _new++)
+	/* 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],bail,user))
+			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++)
+	{
+		int* val_i = (int*) Values[Index].val;
+		char* val_c = (char*) Values[Index].val;
+
+		switch (Values[Index].datatype)
 		{
-			bool added = true;
+			case DT_CHARPTR:
+				ConfValue(Values[Index].tag, Values[Index].value, 0, val_c, &this->config_f);
+			break;
 
-			for (std::vector<std::string>::iterator old = old_module_names.begin(); old != old_module_names.end(); old++)
-			{
-				if (*old == *_new)
-					added = false;
-			}
+			case DT_INTEGER:
+				convert = new char[MAXBUF];
+				ConfValue(Values[Index].tag, Values[Index].value, 0, convert, &this->config_f);
+				*val_i = atoi(convert);
+				delete[] convert;
+			break;
 
-			if (added)
-				added_modules.push_back(*_new);
+			case DT_BOOLEAN:
+				convert = new char[MAXBUF];
+				ConfValue(Values[Index].tag, Values[Index].value, 0, convert, &this->config_f);
+				*val_i = ((*convert == tolower('y')) || (*convert == tolower('t')) || (*convert == '1'));
+				delete[] convert;
+			break;
+
+			case DT_NOTHING:
+			break;
 		}
 
-		for (std::vector<std::string>::iterator oldm = old_module_names.begin(); oldm != old_module_names.end(); oldm++)
+		Values[Index].validation_function(Values[Index].tag, Values[Index].value, Values[Index].val);
+	}
+
+	/* Claim memory for use when reading multiple tags
+	 */
+	for (int n = 0; n < 12; n++)
+		data[n] = new char[MAXBUF];
+
+	/* Read the multiple-tag items (class tags, connect tags, etc)
+	 * and call the callbacks associated with them. We have three
+	 * callbacks for these, a 'start', 'item' and 'end' callback.
+	 */
+	for (int Index = 0; MultiValues[Index].tag; Index++)
+	{
+		MultiValues[Index].init_function(MultiValues[Index].tag);
+
+		int number_of_tags = ConfValueEnum((char*)MultiValues[Index].tag, &this->config_f);
+
+		for (int tagnum = 0; tagnum < number_of_tags; tagnum++)
 		{
-			bool removed = true;
-			for (std::vector<std::string>::iterator newm = new_module_names.begin(); newm != new_module_names.end(); newm++)
+			for (int valuenum = 0; MultiValues[Index].items[valuenum]; valuenum++)
 			{
-				if (*newm == *oldm)
-					removed = false;
-			}
+				ConfValue((char*)MultiValues[Index].tag,(char*)MultiValues[Index].items[valuenum], tagnum, data[valuenum], &this->config_f);
 
-			if (removed)
-				removed_modules.push_back(*oldm);
+				switch (MultiValues[Index].datatype[valuenum])
+				{
+					case DT_CHARPTR:
+						ptr[valuenum] = data[valuenum];
+					break;
+					case DT_INTEGER:
+						r_i[valuenum] = atoi(data[valuenum]);
+						ptr[valuenum] = &r_i[valuenum];
+					break;
+					case DT_BOOLEAN:
+						r_i[valuenum] = ((*data[valuenum] == tolower('y')) || (*data[valuenum] == tolower('t')) || (*data[valuenum] == '1'));
+						ptr[valuenum] = &r_i[valuenum];
+					break;
+					default:
+					break;
+				}
+			}
+			MultiValues[Index].validation_function(MultiValues[Index].tag, (char**)MultiValues[Index].items, ptr, MultiValues[Index].datatype);
 		}
 
-		/*
-		 * now we have added_modules, a vector of modules to be loaded,
-		 * and removed_modules, a vector of modules
-		 * to be removed.
-		 */
-		int rem = 0, add = 0;
+		MultiValues[Index].finish_function(MultiValues[Index].tag);
+	}
+
+	/* Free any memory we claimed
+	 */
+	for (int n = 0; n < 12; n++)
+		delete[] data[n];
+
+	// write once here, to try it out and make sure its ok
+	WritePID(Config->PID);
+
+	log(DEFAULT,"Done reading configuration file, InspIRCd is now starting.");
+
+	/* If we're rehashing, let's load any new modules, and unload old ones
+	 */
+	if (!bail)
+	{
 		if (!removed_modules.empty())
 			for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
 			{
@@ -608,7 +795,6 @@ void ServerConfig::Read(bool bail, userrec* user)
 	}
 }
 
-
 void Exit (int status)
 {
 	if (Config->log_file)
@@ -648,12 +834,12 @@ void Start (void)
 {
 	printf("\033[1;32mInspire Internet Relay Chat Server, compiled %s at %s\n",__DATE__,__TIME__);
 	printf("(C) ChatSpike Development team.\033[0m\n\n");
-	printf("Developers:\033[1;32m Brain, FrostyCoolSlug, w00t, Om\033[0m\n");
-	printf("Others:\033[1;32m See /INFO Output\033[0m\n");
-	printf("Name concept:\033[1;32m   Lord_Zathras\033[0m\n\n");
+	printf("Developers:\t\t\033[1;32mBrain, FrostyCoolSlug, w00t, Om\033[0m\n");
+	printf("Others:\t\t\t\033[1;32mSee /INFO Output\033[0m\n");
+	printf("Name concept:\t\t\033[1;32mLord_Zathras\033[0m\n\n");
 }
 
-void WritePID(std::string filename)
+void WritePID(const std::string &filename)
 {
 	ofstream outfile(filename.c_str());
 	if (outfile.is_open())
@@ -755,6 +941,8 @@ std::string ServerConfig::ConfProcess(char* buffer, long linenumber, std::string
 	long number_of_equals = 0;
 	bool has_open_bracket = false;
 	bool in_quotes = false;
+	char* trailing;
+
 	error = false;
 	if (!buffer)
 	{
@@ -765,61 +953,62 @@ std::string ServerConfig::ConfProcess(char* buffer, long linenumber, std::string
 		if (*d == 9)
 			*d = ' ';
 	while (*buffer == ' ') buffer++;
-	while ((buffer[strlen(buffer)-1] == ' ') && (*buffer)) buffer[strlen(buffer)-1] = '\0';
+	trailing = buffer + strlen(buffer) - 1;
+	while (*trailing == ' ') *trailing-- = '\0';
 
 	// empty lines are syntactically valid, as are comments
 	if (!(*buffer) || buffer[0] == '#')
 		return "";
 
-	for (unsigned int c = 0; c < strlen(buffer); c++)
+	for (char* c = buffer; *c; c++)
 	{
 		// convert all spaces that are OUTSIDE quotes into hardspace (0xA0) as this will make them easier to
 		// search and replace later :)
-		if ((!in_quotes) && (buffer[c] == ' '))
-			buffer[c] = '\xA0';
-		if ((buffer[c] == '<') && (!in_quotes))
+		if ((!in_quotes) && (*c == ' '))
+			*c = '\xA0';
+		if ((*c == '<') && (!in_quotes))
 		{
 			has_open_bracket = true;
-			if (strlen(buffer) == 1)
+			if (!(*(buffer+1)))
 			{
 				*errorstream << "Tag without identifier at " << filename << ":" << linenumber << endl;
 				error = true;
 				return "";
 			}
-			else if ((tolower(buffer[c+1]) < 'a') || (tolower(buffer[c+1]) > 'z'))
+			else if ((tolower(*(c+1)) < 'a') || (tolower(*(c+1)) > 'z'))
 			{
 				*errorstream << "Invalid characters in identifier at " << filename << ":" << linenumber << endl;
 				error = true;
 				return "";
 			}
 		}
-		if (buffer[c] == '"')
+		if (*c == '"')
 		{
 			number_of_quotes++;
 			in_quotes = (!in_quotes);
 		}
-		if ((buffer[c] == '=') && (!in_quotes))
+		if ((*c == '=') && (!in_quotes))
 		{
 			number_of_equals++;
-			if (strlen(buffer) == c)
+			if (*(c+1) == 0)
 			{
 				*errorstream << "Variable without a value at " << filename << ":" << linenumber << endl;
 				error = true;
 				return "";
 			}
-			else if (buffer[c+1] != '"')
+			else if (*(c+1) != '"')
 			{
 				*errorstream << "Variable name not followed immediately by its value at " << filename << ":" << linenumber << endl;
 				error = true;
 				return "";
 			}
-			else if (!c)
+			else if (c == buffer)
 			{
 				*errorstream << "Value without a variable (line starts with '=') at " << filename << ":" << linenumber << endl;
 				error = true;
 				return "";
 			}
-			else if (buffer[c-1] == '\xA0')
+			else if (*(c-1) == '\xA0')
 			{
 				*errorstream << "Variable name not followed immediately by its value at " << filename << ":" << linenumber << endl;
 				error = true;
@@ -828,7 +1017,7 @@ std::string ServerConfig::ConfProcess(char* buffer, long linenumber, std::string
 		}
 	}
 	// no quotes, and no equals. something freaky.
-	if ((!number_of_quotes) || (!number_of_equals) && (strlen(buffer)>2) && (buffer[0]=='<'))
+	if ((!number_of_quotes) || (!number_of_equals) && (strlen(buffer)>2) && (*buffer == '<'))
 	{
 		*errorstream << "Malformed tag at " << filename << ":" << linenumber << endl;
 		error = true;
@@ -870,16 +1059,20 @@ std::string ServerConfig::ConfProcess(char* buffer, long linenumber, std::string
 
 int ServerConfig::fgets_safe(char* buffer, size_t maxsize, FILE* &file)
 {
-	char c_read = '\0';
-	unsigned int bufptr = 0;
-	while ((!feof(file)) && (c_read != '\n') && (c_read != '\r') && (bufptr < maxsize))
+	char c_read = 0;
+	size_t n = 0;
+	char* bufptr = buffer;
+	while ((!feof(file)) && (c_read != '\n') && (c_read != '\r') && (n < maxsize))
 	{
 		c_read = fgetc(file);
 		if ((c_read != '\n') && (c_read != '\r'))
-			buffer[bufptr++] = c_read;
+		{
+			*bufptr++ = c_read;
+			n++;
+		}
 	}
-	buffer[bufptr] = '\0';
-	return bufptr;
+	*bufptr = 0;
+	return bufptr - buffer;
 }
 
 bool ServerConfig::LoadConf(const char* filename, std::stringstream *target, std::stringstream* errorstream)
@@ -913,7 +1106,7 @@ bool ServerConfig::LoadConf(const char* filename, std::stringstream *target, std
 		{
 			if (fgets_safe(buffer, MAXBUF, conf))
 			{
-				if ((!feof(conf)) && (buffer) && (strlen(buffer)))
+				if ((!feof(conf)) && (buffer) && (*buffer))
 				{
 					if ((buffer[0] != '#') && (buffer[0] != '\r')  && (buffer[0] != '\n'))
 					{
@@ -923,13 +1116,13 @@ bool ServerConfig::LoadConf(const char* filename, std::stringstream *target, std
 							char confpath[10240],newconf[10240];
 							// include file directive
 							buf += 15;	// advance to filename
-							for (unsigned int j = 0; j < strlen(buf); j++)
+							for (char* j = buf; *j; j++)
 							{
-								if (buf[j] == '\\')
-									buf[j] = '/';
-								if (buf[j] == '"')
+								if (*j == '\\')
+									*j = '/';
+								if (*j == '"')
 								{
-									buf[j] = '\0';
+									*j = 0;
 									break;
 								}
 							}
@@ -992,23 +1185,22 @@ int ServerConfig::EnumConf(std::stringstream *config, const char* tag)
 
 	std::string x = config->str();
 	const char* buf = x.c_str();
-	long bptr = 0;
-	long len = config->str().length();
+	char* bptr = (char*)buf;
 	
 	ptr = 0;
 	in_token = 0;
 	in_quotes = 0;
 	lastc = '\0';
-	while (bptr<len)
+	while (*bptr)
 	{
 		lastc = c;
-		c = buf[bptr++];
+		c = *bptr++;
 		if ((c == '#') && (lastc == '\n'))
 		{
-			while ((c != '\n') && (bptr<len))
+			while ((c != '\n') && (*bptr))
 			{
 				lastc = c;
-				c = buf[bptr++];
+				c = *bptr++;
 			}
 		}
 		if ((c == '<') && (!in_quotes))
@@ -1016,7 +1208,7 @@ int ServerConfig::EnumConf(std::stringstream *config, const char* tag)
 			tptr = 0;
 			in_token = 1;
 			do {
-				c = buf[bptr++];
+				c = *bptr++;
 				if (c != ' ')
 				{
 					c_tag[tptr++] = c;
@@ -1060,28 +1252,26 @@ int ServerConfig::EnumValues(std::stringstream *config, const char* tag, int ind
 	int ptr = 0;
 	char buffer[MAXBUF], c_tag[MAXBUF], c, lastc;
 	int in_token, in_quotes, tptr, idx = 0;
-	
 	bool correct_tag = false;
 	int num_items = 0;
-
 	const char* buf = config->str().c_str();
-	long bptr = 0;
-	long len = strlen(buf);
-	
+	char* bptr = (char*)buf;
+
 	ptr = 0;
 	in_token = 0;
 	in_quotes = 0;
-	lastc = '\0';
-	while (bptr<len)
+	lastc = 0;
+
+	while (*bptr)
 	{
 		lastc = c;
-		c = buf[bptr++];
+		c = *bptr++;
 		if ((c == '#') && (lastc == '\n'))
 		{
-			while ((c != '\n') && (bptr<len))
+			while ((c != '\n') && (*bptr))
 			{
 				lastc = c;
-				c = buf[bptr++];
+				c = *bptr++;
 			}
 		}
 		if ((c == '<') && (!in_quotes))
@@ -1089,7 +1279,7 @@ int ServerConfig::EnumValues(std::stringstream *config, const char* tag, int ind
 			tptr = 0;
 			in_token = 1;
 			do {
-				c = buf[bptr++];
+				c = *bptr++;
 				if (c != ' ')
 				{
 					c_tag[tptr++] = c;
@@ -1139,42 +1329,33 @@ int ServerConfig::EnumValues(std::stringstream *config, const char* tag, int ind
 }
 
 
-
 int ServerConfig::ConfValueEnum(char* tag, std::stringstream* config)
 {
 	return EnumConf(config,tag);
 }
 
 
-
-/* Retrieves a value from the config file. If there is more than one value of the specified
- * key and section (e.g. for opers etc) then the index value specifies which to retreive, e.g.
- *
- * ConfValue("oper","name",2,result);
- */
-
 int ServerConfig::ReadConf(std::stringstream *config, const char* tag, const char* var, int index, char *result)
 {
 	int ptr = 0;
 	char buffer[65535], c_tag[MAXBUF], c, lastc;
 	int in_token, in_quotes, tptr, idx = 0;
 	char* key;
-
 	std::string x = config->str();
 	const char* buf = x.c_str();
-	long bptr = 0;
-	long len = config->str().length();
+	char* bptr = (char*)buf;
 	
 	ptr = 0;
 	in_token = 0;
 	in_quotes = 0;
-	lastc = '\0';
-	c_tag[0] = '\0';
-	buffer[0] = '\0';
-	while (bptr<len)
+	lastc = 0;
+	c_tag[0] = 0;
+	buffer[0] = 0;
+
+	while (*bptr)
 	{
 		lastc = c;
-		c = buf[bptr++];
+		c = *bptr++;
 		// FIX: Treat tabs as spaces
 		if (c == 9)
 			c = 32;
@@ -1183,7 +1364,7 @@ int ServerConfig::ReadConf(std::stringstream *config, const char* tag, const cha
 			tptr = 0;
 			in_token = 1;
 			do {
-				c = buf[bptr++];
+				c = *bptr++;
 				if (c != ' ')
 				{
 					c_tag[tptr++] = c;
@@ -1226,11 +1407,12 @@ int ServerConfig::ReadConf(std::stringstream *config, const char* tag, const cha
 								key++;
 							}
 							key++;
-							for (unsigned j = 0; j < strlen(key); j++)
+							for (char* j = key; *j; j++)
 							{
-								if (key[j] == '"')
+								if (*j == '"')
 								{
-									key[j] = '\0';
+									*j = 0;
+									break;
 								}
 							}
 							strlcpy(result,key,MAXBUF);
@@ -1270,32 +1452,69 @@ int ServerConfig::ConfValue(char* tag, char* var, int index, char *result,std::s
 	return 0;
 }
 
-
+int ServerConfig::ConfValueInteger(char* tag, char* var, int index, std::stringstream *config)
+{
+	char result[MAXBUF];
+	ReadConf(config, tag, var, index, result);
+	return atoi(result);
+}
 
 // This will bind a socket to a port. It works for UDP/TCP
 int BindSocket (int sockfd, struct sockaddr_in client, struct sockaddr_in server, int port, char* addr)
 {
 	memset((char *)&server,0,sizeof(server));
 	struct in_addr addy;
-	inet_aton(addr,&addy);
-	server.sin_family = AF_INET;
-	if (!*addr)
+	bool resolved = false;
+	char resolved_addr[128];
+
+	if (*addr == '*')
+		*addr = 0;
+
+	if (*addr && !inet_aton(addr,&addy))
 	{
-		server.sin_addr.s_addr = htonl(INADDR_ANY);
+		/* If they gave a hostname, bind to the IP it resolves to */
+		if (CleanAndResolve(resolved_addr, addr, true))
+		{
+			inet_aton(resolved_addr,&addy);
+			log(DEFAULT,"Resolved binding '%s' -> '%s'",addr,resolved_addr);
+			server.sin_addr = addy;
+			resolved = true;
+		}
+		else
+		{
+			log(DEFAULT,"WARNING: Could not resolve '%s' to an IP for binding to on port %d",addr,port);
+			return(FALSE);
+		}
 	}
-	else
+	server.sin_family = AF_INET;
+	if (!resolved)
 	{
-		server.sin_addr = addy;
+		if (!*addr)
+		{
+			server.sin_addr.s_addr = htonl(INADDR_ANY);
+		}
+		else
+		{
+			server.sin_addr = addy;
+		}
 	}
 	server.sin_port = htons(port);
-	if (bind(sockfd,(struct sockaddr*)&server,sizeof(server))<0)
+	if (bind(sockfd,(struct sockaddr*)&server,sizeof(server)) < 0)
 	{
 		return(ERROR);
 	}
 	else
 	{
-		listen(sockfd, Config->MaxConn);
-		return(TRUE);
+		log(DEBUG,"Bound port %s:%d",*addr ? addr : "*",port);
+		if (listen(sockfd, Config->MaxConn) == -1)
+		{
+			log(DEFAULT,"ERROR in listen(): %s",strerror(errno));
+			return(FALSE);
+		}
+		else
+		{
+			return(TRUE);
+		}
 	}
 }