* 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.
*
* ---------------------------------------------------
*/
+/* $Core: libIRCDconfigreader */
+/* $CopyInstall: conf/inspircd.quotes.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.rules.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.motd.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.helpop-full.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.helpop.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.censor.example $(CONPATH) */
+/* $CopyInstall: conf/inspircd.filter.example $(CONPATH) */
+/* $CopyInstall: docs/inspircd.conf.example $(CONPATH) */
+
#include "inspircd.h"
#include <fstream>
#include "xline.h"
/* 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)
{
return (x != IOHookModule.end() ? x->second : NULL);
}
-Module* ServerConfig::GetIOHook(InspSocket* is)
+Module* ServerConfig::GetIOHook(BufferedSocket* is)
{
- std::map<InspSocket*,Module*>::iterator x = SocketIOHookModule.find(is);
+ std::map<BufferedSocket*,Module*>::iterator x = SocketIOHookModule.find(is);
return (x != SocketIOHookModule.end() ? x->second : NULL);
}
}
}
-bool ServerConfig::AddIOHook(Module* iomod, InspSocket* is)
+bool ServerConfig::AddIOHook(Module* iomod, BufferedSocket* is)
{
if (!GetIOHook(is))
{
}
else
{
- throw ModuleException("InspSocket derived class already hooked by another module");
+ throw ModuleException("BufferedSocket derived class already hooked by another module");
return false;
}
}
return false;
}
-bool ServerConfig::DelIOHook(InspSocket* is)
+bool ServerConfig::DelIOHook(BufferedSocket* is)
{
- std::map<InspSocket*,Module*>::iterator x = SocketIOHookModule.find(is);
+ std::map<BufferedSocket*,Module*>::iterator x = SocketIOHookModule.find(is);
if (x != SocketIOHookModule.end())
{
SocketIOHookModule.erase(x);
}
}
-void ServerConfig::Send005(userrec* user)
+void ServerConfig::Send005(User* user)
{
for (std::vector<std::string>::iterator line = ServerInstance->Config->isupport.begin(); line != ServerInstance->Config->isupport.end(); line++)
user->WriteServ("005 %s %s", user->nick, line->c_str());
}
-bool ServerConfig::CheckOnce(char* tag, bool bail, userrec* user)
+bool ServerConfig::CheckOnce(char* tag)
{
int count = ConfValueEnum(this->config_data, tag);
return true;
}
-bool NoValidation(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool NoValidation(ServerConfig*, const char*, const char*, ValueItem&)
{
return true;
}
-bool ValidateMaxTargets(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+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))
{
return true;
}
-bool ValidateSoftLimit(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateSoftLimit(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if ((data.GetInteger() < 1) || (data.GetInteger() > MAXCLIENTS))
{
return true;
}
-bool ValidateMaxConn(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateMaxConn(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if (data.GetInteger() > SOMAXCONN)
conf->GetInstance()->Log(DEFAULT,"WARNING: <options:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
std::string thiscmd;
/* Enable everything first */
- for (command_table::iterator x = ServerInstance->Parser->cmdlist.begin(); x != ServerInstance->Parser->cmdlist.end(); x++)
+ for (Commandable::iterator x = ServerInstance->Parser->cmdlist.begin(); x != ServerInstance->Parser->cmdlist.end(); x++)
x->second->Disable(false);
/* Now disable all the ones which the user wants disabled */
while (dcmds >> thiscmd)
{
- command_table::iterator cm = ServerInstance->Parser->cmdlist.find(thiscmd);
+ Commandable::iterator cm = ServerInstance->Parser->cmdlist.find(thiscmd);
if (cm != ServerInstance->Parser->cmdlist.end())
{
cm->second->Disable(true);
return true;
}
-bool ValidateDnsServer(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateDnsServer(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if (!*(data.GetString()))
{
return true;
}
-bool ValidateServerName(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateServerName(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
/* If we already have a servername, and they changed it, we should throw an exception. */
if ((strcasecmp(conf->ServerName, data.GetString())) && (*conf->ServerName))
{
throw CoreException("Configuration error: You cannot change your servername at runtime! Please restart your server for this change to be applied.");
- /* XXX: We don't actually reach this return of course... */
+ /* We don't actually reach this return of course... */
return false;
}
if (!strchr(data.GetString(),'.'))
return true;
}
-bool ValidateNetBufferSize(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateNetBufferSize(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if ((!data.GetInteger()) || (data.GetInteger() > 65535) || (data.GetInteger() < 1024))
{
return true;
}
-bool ValidateMaxWho(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateMaxWho(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
if ((data.GetInteger() > 65535) || (data.GetInteger() < 1))
{
return true;
}
-bool ValidateLogLevel(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateLogLevel(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
std::string dbg = data.GetString();
conf->LogLevel = DEFAULT;
return true;
}
-bool ValidateMotd(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateMotd(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
conf->ReadFile(conf->MOTD, data.GetString());
return true;
}
-bool ValidateNotEmpty(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateNotEmpty(ServerConfig*, const char* tag, const char*, ValueItem &data)
{
if (!*data.GetString())
throw CoreException(std::string("The value for ")+tag+" cannot be empty!");
return true;
}
-bool ValidateRules(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateRules(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
conf->ReadFile(conf->RULES, data.GetString());
return true;
}
-bool ValidateModeLists(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateModeLists(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
memset(conf->HideModeLists, 0, 256);
for (const unsigned char* x = (const unsigned char*)data.GetString(); *x; ++x)
return true;
}
-bool ValidateExemptChanOps(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateExemptChanOps(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
memset(conf->ExemptChanOps, 0, 256);
for (const unsigned char* x = (const unsigned char*)data.GetString(); *x; ++x)
return true;
}
-bool ValidateInvite(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateInvite(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
std::string v = data.GetString();
return true;
}
-bool ValidateSID(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateSID(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
int sid = data.GetInteger();
if ((sid > 999) || (sid < 0))
return true;
}
-bool ValidateWhoWas(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
+bool ValidateWhoWas(ServerConfig* conf, const char*, const char*, ValueItem &data)
{
conf->WhoWasMaxKeep = conf->GetInstance()->Duration(data.GetString());
conf->GetInstance()->Log(DEFAULT,"WARNING: <whowas:maxkeep> value less than 3600, setting to default 3600");
}
- command_t* whowas_command = conf->GetInstance()->Parser->GetHandler("WHOWAS");
+ Command* whowas_command = conf->GetInstance()->Parser->GetHandler("WHOWAS");
if (whowas_command)
{
std::deque<classbase*> params;
/* Callback called before processing the first <connect> tag
*/
-bool InitConnect(ServerConfig* conf, const char* tag)
+bool InitConnect(ServerConfig* conf, const char*)
{
conf->GetInstance()->Log(DEFAULT,"Reading connect classes...");
- conf->Classes.clear();
+
+ for (ClassVector::iterator i = conf->Classes.begin(); i != conf->Classes.end(); i++)
+ {
+ ConnectClass *c = *i;
+
+ conf->GetInstance()->Log(DEBUG, "Address of class is %p", c);
+ }
+
+ for (ClassVector::iterator i = conf->Classes.begin(); i != conf->Classes.end(); 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!");
+ 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);
+ }
+
return true;
}
/* Callback called to process a single <connect> tag
*/
-bool DoConnect(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+bool DoConnect(ServerConfig* conf, const char*, char**, ValueList &values, int*)
{
ConnectClass c;
const char* allow = values[0].GetString(); /* Yeah, there are a lot of values. Live with it. */
const char* name = values[12].GetString();
const char* parent = values[13].GetString();
int maxchans = values[14].GetInteger();
+ unsigned long limit = values[15].GetInteger();
+
+ /*
+ * duplicates check: Now we don't delete all connect classes on rehash, we need to ensure we don't add dupes.
+ * easier said than done, but for now we'll just disallow anything with a duplicate host or name. -- w00t
+ */
+ for (ClassVector::iterator item = conf->Classes.begin(); item != conf->Classes.end(); ++item)
+ {
+ ConnectClass* c = *item;
+ if ((*name && (c->GetName() == name)) || (*allow && (c->GetHost() == allow)) || (*deny && (c->GetHost() == deny)))
+ {
+ /* reenable class so users can be shoved into it :P */
+ c->SetDisabled(false);
+ conf->GetInstance()->Log(DEFAULT, "Not adding class, it already exists!");
+ return true;
+ }
+ }
+
+ conf->GetInstance()->Log(DEFAULT,"Adding a connect class!");
if (*parent)
{
/* Find 'parent' and inherit a new class from it,
* then overwrite any values that are set here
*/
- for (ClassVector::iterator item = conf->Classes.begin(); item != conf->Classes.end(); ++item)
+ ClassVector::iterator item = conf->Classes.begin();
+ for (; item != conf->Classes.end(); ++item)
{
- if (item->GetName() == parent)
+ ConnectClass* c = *item;
+ conf->GetInstance()->Log(DEBUG,"Class: %s", c->GetName().c_str());
+ if (c->GetName() == parent)
{
- ConnectClass c(name, *item);
- c.Update(timeout, flood, *allow ? allow : deny, pingfreq, password, threshold, sendq, recvq, localmax, globalmax, maxchans, port);
- conf->Classes.push_back(c);
+ ConnectClass* newclass = new ConnectClass(name, c);
+ newclass->Update(timeout, flood, *allow ? allow : deny, pingfreq, password, threshold, sendq, recvq, localmax, globalmax, maxchans, port, limit);
+ conf->Classes.push_back(newclass);
+ break;
}
}
- throw CoreException("Class name '" + std::string(name) + "' is configured to inherit from class '" + std::string(parent) + "' which cannot be found.");
+ if (item == conf->Classes.end())
+ throw CoreException("Class name '" + std::string(name) + "' is configured to inherit from class '" + std::string(parent) + "' which cannot be found.");
}
else
{
if (*allow)
{
- ConnectClass c(name, timeout, flood, allow, pingfreq, password, threshold, sendq, recvq, localmax, globalmax, maxchans);
- c.SetPort(port);
+ ConnectClass* c = new ConnectClass(name, timeout, flood, allow, pingfreq, password, threshold, sendq, recvq, localmax, globalmax, maxchans);
+ c->limit = limit;
+ c->SetPort(port);
conf->Classes.push_back(c);
}
else
{
- ConnectClass c(name, deny);
- c.SetPort(port);
+ ConnectClass* c = new ConnectClass(name, deny);
+ c->SetPort(port);
conf->Classes.push_back(c);
}
}
/* Callback called when there are no more <connect> tags
*/
-bool DoneConnect(ServerConfig* conf, const char* tag)
+bool DoneConnect(ServerConfig *conf, const char*)
{
+ conf->GetInstance()->Log(DEFAULT, "Done adding connect classes!");
return true;
}
/* Callback called before processing the first <uline> tag
*/
-bool InitULine(ServerConfig* conf, const char* tag)
+bool InitULine(ServerConfig* conf, const char*)
{
conf->ulines.clear();
return true;
/* Callback called to process a single <uline> tag
*/
-bool DoULine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+bool DoULine(ServerConfig* conf, const char*, char**, ValueList &values, int*)
{
const char* server = values[0].GetString();
const bool silent = values[1].GetBool();
/* Callback called when there are no more <uline> tags
*/
-bool DoneULine(ServerConfig* conf, const char* tag)
+bool DoneULine(ServerConfig*, const char*)
{
return true;
}
/* Callback called before processing the first <module> tag
*/
-bool InitModule(ServerConfig* conf, const char* tag)
+bool InitModule(ServerConfig* conf, const char*)
{
old_module_names.clear();
new_module_names.clear();
/* Callback called to process a single <module> tag
*/
-bool DoModule(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+bool DoModule(ServerConfig*, const char*, char**, ValueList &values, int*)
{
const char* modname = values[0].GetString();
new_module_names.push_back(modname);
/* Callback called when there are no more <module> tags
*/
-bool DoneModule(ServerConfig* conf, const char* tag)
+bool DoneModule(ServerConfig*, const char*)
{
// 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
/* Callback called before processing the first <banlist> tag
*/
-bool InitMaxBans(ServerConfig* conf, const char* tag)
+bool InitMaxBans(ServerConfig* conf, const char*)
{
conf->maxbans.clear();
return true;
/* Callback called to process a single <banlist> tag
*/
-bool DoMaxBans(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
+bool DoMaxBans(ServerConfig* conf, const char*, char**, ValueList &values, int*)
{
const char* channel = values[0].GetString();
int limit = values[1].GetInteger();
/* Callback called when there are no more <banlist> tags.
*/
-bool DoneMaxBans(ServerConfig* conf, const char* tag)
+bool DoneMaxBans(ServerConfig*, const char*)
{
return true;
}
-void ServerConfig::ReportConfigError(const std::string &errormessage, bool bail, userrec* user)
+void ServerConfig::ReportConfigError(const std::string &errormessage, bool bail, User* user)
{
ServerInstance->Log(DEFAULT, "There were errors in your configuration file: %s", errormessage.c_str());
if (bail)
}
}
-void ServerConfig::Read(bool bail, userrec* user)
+void ServerConfig::Read(bool bail, User* user)
{
static char debug[MAXBUF]; /* Temporary buffer for debugging value */
static char maxkeep[MAXBUF]; /* Temporary buffer for WhoWasMaxKeep value */
/* 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}
+ {"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", "0", new ValueContainerInt (&this->sid), DT_NOSPACES, 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_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
{"connect",
{"allow", "deny", "password", "timeout", "pingfreq", "flood",
"threshold", "sendq", "recvq", "localmax", "globalmax", "port",
- "name", "parent", "maxchans",
+ "name", "parent", "maxchans", "limit",
NULL},
{"", "", "", "", "120", "",
"", "", "", "3", "3", "0",
- "", "", "0",
+ "", "", "0", "0",
NULL},
- {DT_CHARPTR, DT_CHARPTR, DT_CHARPTR, DT_INTEGER, 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_CHARPTR, DT_CHARPTR, 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",
{"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},
{"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},
+ {NULL},
+ {0},
+ NULL, NULL, NULL}
};
include_stack.clear();
/* 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))
+ if (!CheckOnce(Once[Index]))
return;
/* Read the values of all the tags which occur once or not at all, and call their callbacks.
{
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);
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;
{
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];
{
for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
{
- if (ServerInstance->UnloadModule(removing->c_str()))
+ if (ServerInstance->Modules->Unload(removing->c_str()))
{
ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
else
{
if (user)
- user->WriteServ("972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ServerInstance->ModuleError());
+ user->WriteServ("972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ServerInstance->Modules->LastError());
}
}
}
{
for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
{
- if (ServerInstance->LoadModule(adding->c_str()))
+ if (ServerInstance->Modules->Load(adding->c_str()))
{
ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
else
{
if (user)
- user->WriteServ("974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ServerInstance->ModuleError());
+ user->WriteServ("974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ServerInstance->Modules->LastError());
}
}
}
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] != '/')
{
if((pos = confpath.rfind("/")) != std::string::npos)
{
}
else
{
- errorstream << "Couldn't get config path from: " << confpath << std::endl;
+ errorstream << "Couldn't get config path from: " << ServerInstance->ConfigFileName << std::endl;
return false;
}
}
bool ServerConfig::ConfValue(ConfigDataHash &target, const std::string &tag, const std::string &var, const std::string &default_value, int index, std::string &result, bool allow_linefeeds)
{
ConfigDataHash::size_type pos = index;
- if((pos >= 0) && (pos < target.count(tag)))
+ if (pos < target.count(tag))
{
ConfigDataHash::iterator iter = target.find(tag);
{
ConfigDataHash::size_type pos = index;
- if((pos >= 0) && (pos < target.count(tag)))
+ if (pos < target.count(tag))
{
ConfigDataHash::const_iterator iter = target.find(tag);
return ServerInstance;
}
+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;
+}
ValueItem::ValueItem(int value)
{
return (GetInteger() || v == "yes" || v == "true");
}
+
+
+
+/*
+ * XXX should this be in a class? -- w00t
+ */
+bool InitTypes(ServerConfig* conf, const char*)
+{
+ if (conf->opertypes.size())
+ {
+ for (opertype_t::iterator n = conf->opertypes.begin(); n != conf->opertypes.end(); n++)
+ {
+ if (n->second)
+ delete[] n->second;
+ }
+ }
+
+ conf->opertypes.clear();
+ return true;
+}
+
+/*
+ * XXX should this be in a class? -- w00t
+ */
+bool InitClasses(ServerConfig* conf, const char*)
+{
+ if (conf->operclass.size())
+ {
+ for (operclass_t::iterator n = conf->operclass.begin(); n != conf->operclass.end(); n++)
+ {
+ if (n->second)
+ delete[] n->second;
+ }
+ }
+
+ conf->operclass.clear();
+ return true;
+}
+
+/*
+ * XXX should this be in a class? -- w00t
+ */
+bool DoType(ServerConfig* conf, const char*, char**, ValueList &values, int*)
+{
+ const char* TypeName = values[0].GetString();
+ const char* Classes = values[1].GetString();
+
+ conf->opertypes[TypeName] = strnewdup(Classes);
+ return true;
+}
+
+/*
+ * XXX should this be in a class? -- w00t
+ */
+bool DoClass(ServerConfig* conf, const char*, char**, ValueList &values, int*)
+{
+ const char* ClassName = values[0].GetString();
+ const char* CommandList = values[1].GetString();
+
+ conf->operclass[ClassName] = strnewdup(CommandList);
+ return true;
+}
+
+/*
+ * XXX should this be in a class? -- w00t
+ */
+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;
+}
+