* +------------------------------------+
*
* InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
+ * E-mail:
+ * <brain@chatspike.net>
+ * <Craig@chatspike.net>
*
* Written by Craig Edwards, Craig McLure, and others.
* This program is free but copyrighted software; see
- * the file COPYING for details.
+ * the file COPYING for details.
*
* ---------------------------------------------------
*/
-#include "inspircd_config.h"
#include "configreader.h"
-#include <string>
#include <sstream>
-#include <iostream>
#include <fstream>
-#include "message.h"
#include "inspircd.h"
-#include "inspstring.h"
-#include "helperfuncs.h"
-#include "userprocess.h"
#include "xline.h"
-extern InspIRCd* ServerInstance;
-extern time_t TIME;
-
-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()
+ServerConfig::ServerConfig(InspIRCd* Instance) : ServerInstance(Instance)
{
this->ClearStack();
*TempDir = *ServerName = *Network = *ServerDesc = *AdminName = '\0';
*HideWhoisServer = *AdminEmail = *AdminNick = *diepass = *restartpass = '\0';
*CustomVersion = *motd = *rules = *PrefixQuit = *DieValue = *DNSServer = '\0';
- *OperOnlyStats = *ModPath = *MyExecutable = *DisabledCommands = *PID = '\0';
+ *UserStats = *ModPath = *MyExecutable = *DisabledCommands = *PID = '\0';
log_file = NULL;
NoUserDns = forcedebug = OperSpyWhois = nofork = HideBans = HideSplits = false;
- writelog = AllowHalfop = true;
+ CycleHosts = writelog = AllowHalfop = true;
dns_timeout = DieDelay = 5;
MaxTargets = 20;
NetBufferSize = 10240;
if (bail)
{
printf("There were errors in your configuration:\nYou have more than one <%s> tag, this is not permitted.\n",tag);
- Exit(0);
+ InspIRCd::Exit(ERROR);
}
else
{
}
else
{
- WriteOpers("There were errors in the configuration file:");
- WriteOpers("You have more than one <%s> tag, this is not permitted.\n",tag);
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("You have more than one <%s> tag, this is not permitted.\n",tag);
}
}
return false;
if (bail)
{
printf("There were errors in your configuration:\nYou have not defined a <%s> tag, this is required.\n",tag);
- Exit(0);
+ InspIRCd::Exit(ERROR);
}
else
{
}
else
{
- WriteOpers("There were errors in the configuration file:");
- WriteOpers("You have not defined a <%s> tag, this is required.",tag);
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("You have not defined a <%s> tag, this is required.",tag);
}
}
return false;
return true;
}
-bool NoValidation(const char* tag, const char* value, void* data)
+bool NoValidation(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- log(DEBUG,"No validation for <%s:%s>",tag,value);
+ conf->GetInstance()->Log(DEBUG,"No validation for <%s:%s>",tag,value);
return true;
}
-bool ValidateTempDir(const char* tag, const char* value, void* data)
+bool ValidateTempDir(ServerConfig* conf, const char* tag, const char* value, void* data)
{
char* x = (char*)data;
if (!*x)
return true;
}
-bool ValidateMaxTargets(const char* tag, const char* value, void* data)
+bool ValidateMaxTargets(ServerConfig* conf, 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.");
+ conf->GetInstance()->Log(DEFAULT,"WARNING: <options:maxtargets> value is greater than 31 or less than 0, set to 20.");
*x = 20;
}
return true;
}
-bool ValidateSoftLimit(const char* tag, const char* value, void* data)
+bool ValidateSoftLimit(ServerConfig* conf, 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);
+ conf->GetInstance()->Log(DEFAULT,"WARNING: <options:softlimit> value is greater than %d or less than 0, set to %d.",MAXCLIENTS,MAXCLIENTS);
*x = MAXCLIENTS;
}
return true;
}
-bool ValidateMaxConn(const char* tag, const char* value, void* data)
+bool ValidateMaxConn(ServerConfig* conf, 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!");
+ conf->GetInstance()->Log(DEFAULT,"WARNING: <options:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
if (!*x)
*x = SOMAXCONN;
return true;
}
-bool ValidateDnsTimeout(const char* tag, const char* value, void* data)
+bool ValidateDnsTimeout(ServerConfig* conf, const char* tag, const char* value, void* data)
{
int* x = (int*)data;
if (!*x)
nspace::hash_map<std::string,command_t*>::iterator cm = ServerInstance->Parser->cmdlist.find(thiscmd);
if (cm != ServerInstance->Parser->cmdlist.end())
{
- log(DEBUG,"Disabling command '%s'",cm->second->command.c_str());
+ ServerInstance->Log(DEBUG,"Disabling command '%s'",cm->second->command.c_str());
cm->second->Disable(true);
}
}
return true;
}
-bool ValidateDnsServer(const char* tag, const char* value, void* data)
+bool ValidateDnsServer(ServerConfig* conf, 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...");
+ conf->GetInstance()->Log(DEFAULT,"WARNING: <dns:server> not defined, attempting to find working server in /etc/resolv.conf...");
ifstream resolv("/etc/resolv.conf");
std::string nameserver;
bool found_server = false;
resolv >> nameserver;
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());
+ conf->GetInstance()->Log(DEFAULT,"<dns:server> set to '%s' as first resolver in /etc/resolv.conf.",nameserver.c_str());
}
}
if (!found_server)
{
- log(DEFAULT,"/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
+ conf->GetInstance()->Log(DEFAULT,"/etc/resolv.conf contains no viable nameserver entries! Defaulting to nameserver '127.0.0.1'!");
strlcpy(x,"127.0.0.1",MAXBUF);
}
}
else
{
- log(DEFAULT,"/etc/resolv.conf can't be opened! Defaulting to nameserver '127.0.0.1'!");
+ conf->GetInstance()->Log(DEFAULT,"/etc/resolv.conf can't be opened! Defaulting to nameserver '127.0.0.1'!");
strlcpy(x,"127.0.0.1",MAXBUF);
}
}
return true;
}
-bool ValidateModPath(const char* tag, const char* value, void* data)
+bool ValidateModPath(ServerConfig* conf, const char* tag, const char* value, void* data)
{
char* x = (char*)data;
if (!*x)
}
-bool ValidateServerName(const char* tag, const char* value, void* data)
+bool ValidateServerName(ServerConfig* conf, 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,'.');
+ conf->GetInstance()->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)
+bool ValidateNetBufferSize(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- if ((!ServerInstance->Config->NetBufferSize) || (ServerInstance->Config->NetBufferSize > 65535) || (ServerInstance->Config->NetBufferSize < 1024))
+ if ((!conf->NetBufferSize) || (conf->NetBufferSize > 65535) || (conf->NetBufferSize < 1024))
{
- log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
- ServerInstance->Config->NetBufferSize = 10240;
+ conf->GetInstance()->Log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
+ conf->NetBufferSize = 10240;
}
return true;
}
-bool ValidateMaxWho(const char* tag, const char* value, void* data)
+bool ValidateMaxWho(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- if ((!ServerInstance->Config->MaxWhoResults) || (ServerInstance->Config->MaxWhoResults > 65535) || (ServerInstance->Config->MaxWhoResults < 1))
+ if ((!conf->MaxWhoResults) || (conf->MaxWhoResults > 65535) || (conf->MaxWhoResults < 1))
{
- log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
- ServerInstance->Config->MaxWhoResults = 128;
+ conf->GetInstance()->Log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
+ conf->MaxWhoResults = 128;
}
return true;
}
-bool ValidateLogLevel(const char* tag, const char* value, void* data)
+bool ValidateLogLevel(ServerConfig* conf, const char* tag, const char* value, void* data)
{
const char* dbg = (const char*)data;
- ServerInstance->Config->LogLevel = DEFAULT;
+ conf->LogLevel = DEFAULT;
if (!strcmp(dbg,"debug"))
{
- ServerInstance->Config->LogLevel = DEBUG;
- ServerInstance->Config->debugging = 1;
+ conf->LogLevel = DEBUG;
+ conf->debugging = 1;
}
else if (!strcmp(dbg,"verbose"))
- ServerInstance->Config->LogLevel = VERBOSE;
+ conf->LogLevel = VERBOSE;
else if (!strcmp(dbg,"default"))
- ServerInstance->Config->LogLevel = DEFAULT;
+ conf->LogLevel = DEFAULT;
else if (!strcmp(dbg,"sparse"))
- ServerInstance->Config->LogLevel = SPARSE;
+ conf->LogLevel = SPARSE;
else if (!strcmp(dbg,"none"))
- ServerInstance->Config->LogLevel = NONE;
+ conf->LogLevel = NONE;
return true;
}
-bool ValidateMotd(const char* tag, const char* value, void* data)
+bool ValidateMotd(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- readfile(ServerInstance->Config->MOTD,ServerInstance->Config->motd);
+ conf->ReadFile(conf->MOTD,conf->motd);
return true;
}
-bool ValidateRules(const char* tag, const char* value, void* data)
+bool ValidateRules(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- readfile(ServerInstance->Config->RULES,ServerInstance->Config->rules);
+ conf->ReadFile(conf->RULES,conf->rules);
return true;
}
/* Callback called before processing the first <connect> tag
*/
-bool InitConnect(const char* tag)
+bool InitConnect(ServerConfig* conf, const char* tag)
{
- log(DEFAULT,"Reading connect classes...");
- ServerInstance->Config->Classes.clear();
+ conf->GetInstance()->Log(DEFAULT,"Reading connect classes...");
+ conf->Classes.clear();
return true;
}
/* Callback called to process a single <connect> tag
*/
-bool DoConnect(const char* tag, char** entries, void** values, int* types)
+bool DoConnect(ServerConfig* conf, 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. */
{
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());
+ conf->GetInstance()->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;
c.registration_timeout = 90;
if (c.pingtime == 0)
c.pingtime = 120;
- ServerInstance->Config->Classes.push_back(c);
+ conf->Classes.push_back(c);
}
else
{
c.host = deny;
c.type = CC_DENY;
- ServerInstance->Config->Classes.push_back(c);
- log(DEBUG,"Read connect class type DENY, host=%s",deny);
+ conf->Classes.push_back(c);
+ conf->GetInstance()->Log(DEBUG,"Read connect class type DENY, host=%s",deny);
}
return true;
/* Callback called when there are no more <connect> tags
*/
-bool DoneConnect(const char* tag)
+bool DoneConnect(ServerConfig* conf, const char* tag)
{
- log(DEBUG,"DoneConnect called for tag: %s",tag);
+ conf->GetInstance()->Log(DEBUG,"DoneConnect called for tag: %s",tag);
return true;
}
/* Callback called before processing the first <uline> tag
*/
-bool InitULine(const char* tag)
+bool InitULine(ServerConfig* conf, const char* tag)
{
- ServerInstance->Config->ulines.clear();
+ conf->ulines.clear();
return true;
}
/* Callback called to process a single <uline> tag
*/
-bool DoULine(const char* tag, char** entries, void** values, int* types)
+bool DoULine(ServerConfig* conf, const char* tag, char** entries, void** values, int* types)
{
char* server = (char*)values[0];
- log(DEBUG,"Read ULINE '%s'",server);
- ServerInstance->Config->ulines.push_back(server);
+ conf->GetInstance()->Log(DEBUG,"Read ULINE '%s'",server);
+ conf->ulines.push_back(server);
return true;
}
/* Callback called when there are no more <uline> tags
*/
-bool DoneULine(const char* tag)
+bool DoneULine(ServerConfig* conf, const char* tag)
{
return true;
}
/* Callback called before processing the first <module> tag
*/
-bool InitModule(const char* tag)
+bool InitModule(ServerConfig* conf, const char* tag)
{
old_module_names.clear();
new_module_names.clear();
added_modules.clear();
removed_modules.clear();
- for (std::vector<std::string>::iterator t = ServerInstance->Config->module_names.begin(); t != ServerInstance->Config->module_names.end(); t++)
+ for (std::vector<std::string>::iterator t = conf->module_names.begin(); t != conf->module_names.end(); t++)
{
old_module_names.push_back(*t);
}
/* Callback called to process a single <module> tag
*/
-bool DoModule(const char* tag, char** entries, void** values, int* types)
+bool DoModule(ServerConfig* conf, const char* tag, char** entries, void** values, int* types)
{
char* modname = (char*)values[0];
new_module_names.push_back(modname);
/* Callback called when there are no more <module> tags
*/
-bool DoneModule(const char* tag)
+bool DoneModule(ServerConfig* conf, 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
/* Callback called before processing the first <banlist> tag
*/
-bool InitMaxBans(const char* tag)
+bool InitMaxBans(ServerConfig* conf, const char* tag)
{
- ServerInstance->Config->maxbans.clear();
+ conf->maxbans.clear();
return true;
}
/* Callback called to process a single <banlist> tag
*/
-bool DoMaxBans(const char* tag, char** entries, void** values, int* types)
+bool DoMaxBans(ServerConfig* conf, const char* tag, char** entries, void** values, int* types)
{
char* channel = (char*)values[0];
int* limit = (int*)values[1];
- ServerInstance->Config->maxbans[channel] = *limit;
+ conf->maxbans[channel] = *limit;
return true;
}
/* Callback called when there are no more <banlist> tags.
*/
-bool DoneMaxBans(const char* tag)
+bool DoneMaxBans(ServerConfig* conf, const char* tag)
{
return true;
}
std::ostringstream 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 };
+ static char* Once[] = { "server", "admin", "files", "power", "options", NULL };
/* These tags can occur ONCE or not at all */
static InitialConfig Values[] = {
{"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", "pause", &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},
{"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", "userstats", &this->UserStats, 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", "tempdir", &this->TempDir, DT_CHARPTR, ValidateTempDir},
{"options", "nouserdns", &this->NoUserDns, DT_BOOLEAN, NoValidation},
{"options", "syntaxhints", &this->SyntaxHints, DT_BOOLEAN, NoValidation},
+ {"options", "cyclehosts", &this->CycleHosts, DT_BOOLEAN, NoValidation},
{"pid", "file", &this->PID, DT_CHARPTR, NoValidation},
{NULL}
};
if (this->LoadConf(newconfig, CONFIG_FILE, errstr))
{
/* If we succeeded, set the ircd config to the new one */
- this->config_data = newconfig;
-
-/* int c = 1;
- std::string last;
-
- for(ConfigDataHash::const_iterator i = this->config_data.begin(); i != this->config_data.end(); i++)
- {
- c = (i->first != last) ? 1 : c+1;
- last = i->first;
-
- std::cout << "[" << i->first << " " << c << "/" << this->config_data.count(i->first) << "]" << std::endl;
-
- for(KeyValList::const_iterator j = i->second.begin(); j != i->second.end(); j++)
- std::cout << "\t" << j->first << " = " << j->second << std::endl;
-
- std::cout << "[/" << i->first << " " << c << "/" << this->config_data.count(i->first) << "]" << std::endl;
- }
- */ }
+ this->config_data = newconfig;
+ }
else
{
- log(DEFAULT, "There were errors in your configuration:\n%s", errstr.str().c_str());
+ ServerInstance->Log(DEFAULT, "There were errors in your configuration:\n%s", errstr.str().c_str());
if (bail)
{
- /* Unneeded because of the log() aboive? */
+ /* Unneeded because of the ServerInstance->Log() aboive? */
printf("There were errors in your configuration:\n%s",errstr.str().c_str());
- Exit(0);
+ InspIRCd::Exit(ERROR);
}
else
{
}
else
{
- WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
while(start < errors.length())
{
- WriteOpers(errors.substr(start, 360).c_str());
+ ServerInstance->WriteOpers(errors.substr(start, 360).c_str());
start += 360;
}
}
break;
}
- Values[Index].validation_function(Values[Index].tag, Values[Index].value, Values[Index].val);
+ Values[Index].validation_function(this, Values[Index].tag, Values[Index].value, Values[Index].val);
}
/* Claim memory for use when reading multiple tags
/* XXX - Make this use ConfValueInteger and so on */
for (int Index = 0; MultiValues[Index].tag; Index++)
{
- MultiValues[Index].init_function(MultiValues[Index].tag);
+ MultiValues[Index].init_function(this, MultiValues[Index].tag);
int number_of_tags = ConfValueEnum(this->config_data, MultiValues[Index].tag);
break;
}
}
- MultiValues[Index].validation_function(MultiValues[Index].tag, (char**)MultiValues[Index].items, ptr, MultiValues[Index].datatype);
+ MultiValues[Index].validation_function(this, MultiValues[Index].tag, (char**)MultiValues[Index].items, ptr, MultiValues[Index].datatype);
}
- MultiValues[Index].finish_function(MultiValues[Index].tag);
+ MultiValues[Index].finish_function(this, MultiValues[Index].tag);
}
/* Free any memory we claimed
// write once here, to try it out and make sure its ok
ServerInstance->WritePID(this->PID);
- log(DEFAULT,"Done reading configuration file, InspIRCd is now starting.");
+ ServerInstance->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)
{
- ServerInstance->stats->BoundPortCount = BindPorts(false);
+ int found_ports;
+ ServerInstance->stats->BoundPortCount = ServerInstance->BindPorts(false, found_ports);
if (!removed_modules.empty())
for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
{
if (ServerInstance->UnloadModule(removing->c_str()))
{
- WriteOpers("*** REHASH UNLOADED MODULE: %s",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());
{
if (ServerInstance->LoadModule(adding->c_str()))
{
- 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());
}
}
- 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());
+ 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 ((ch == '\\') && (in_quote) && (in_tag))
{
line += ch;
- log(DEBUG,"Escape sequence in config line.");
+ ServerInstance->Log(DEBUG,"Escape sequence in config line.");
char real_character;
if (conf.get(real_character))
{
- log(DEBUG,"Escaping %c", real_character);
+ ServerInstance->Log(DEBUG,"Escaping %c", real_character);
+ if (real_character == 'n')
+ real_character = '\n';
line += real_character;
continue;
}
if ((*c == '\\') && (in_quote))
{
c++;
- current_value += *c;
+ if (*c == 'n')
+ current_value += '\n';
+ else
+ current_value += *c;
continue;
}
if (*c == '"')
}
else if(pos == 0)
{
- log(DEBUG, "No <%s> tags in config file.", tag.c_str());
+ ServerInstance->Log(DEBUG, "No <%s> tags in config file.", tag.c_str());
}
else
{
- log(DEBUG, "ConfValue got an out-of-range index %d, there are only %d occurences of %s", pos, target.count(tag), tag.c_str());
+ ServerInstance->Log(DEBUG, "ConfValue got an out-of-range index %d, there are only %d occurences of %s", pos, target.count(tag), tag.c_str());
}
return false;
}
else if(pos == 0)
{
- log(DEBUG, "No <%s> tags in config file.", tag.c_str());
+ ServerInstance->Log(DEBUG, "No <%s> tags in config file.", tag.c_str());
}
else
{
- log(DEBUG, "ConfVarEnum got an out-of-range index %d, there are only %d occurences of %s", pos, target.count(tag), tag.c_str());
+ ServerInstance->Log(DEBUG, "ConfVarEnum got an out-of-range index %d, there are only %d occurences of %s", pos, target.count(tag), tag.c_str());
}
return 0;
}
+
+/** Read the contents of a file located by `fname' into a file_cache pointed at by `F'.
+ */
+bool ServerConfig::ReadFile(file_cache &F, const char* fname)
+{
+ FILE* file;
+ char linebuf[MAXBUF];
+
+ F.clear();
+
+ if (*fname != '/')
+ {
+ std::string::size_type pos;
+ std::string confpath = CONFIG_FILE;
+ if((pos = confpath.find("/inspircd.conf")) != std::string::npos)
+ {
+ /* Leaves us with just the path */
+ std::string newfile = confpath.substr(0, pos) + std::string("/") + fname;
+ file = fopen(newfile.c_str(), "r");
+
+ }
+ }
+ else
+ file = fopen(fname, "r");
+
+ if (file)
+ {
+ while (!feof(file))
+ {
+ fgets(linebuf, sizeof(linebuf), file);
+ linebuf[strlen(linebuf)-1] = 0;
+
+ if (!feof(file))
+ {
+ F.push_back(*linebuf ? linebuf : " ");
+ }
+ }
+
+ fclose(file);
+ }
+ else
+ return false;
+
+ return true;
+}
+
+bool ServerConfig::FileExists(const char* file)
+{
+ FILE *input;
+ if ((input = fopen (file, "r")) == NULL)
+ {
+ return false;
+ }
+ else
+ {
+ fclose(input);
+ return true;
+ }
+}
+
+char* ServerConfig::CleanFilename(char* name)
+{
+ char* p = name + strlen(name);
+ while ((p != name) && (*p != '/')) p--;
+ return (p != name ? ++p : p);
+}
+
+
+bool ServerConfig::DirValid(const char* dirandfile)
+{
+ char work[MAXBUF];
+ char buffer[MAXBUF];
+ char otherdir[MAXBUF];
+ int p;
+
+ strlcpy(work, dirandfile, MAXBUF);
+ p = strlen(work);
+
+ // we just want the dir
+ while (*work)
+ {
+ if (work[p] == '/')
+ {
+ work[p] = '\0';
+ break;
+ }
+
+ work[p--] = '\0';
+ }
+
+ // Get the current working directory
+ if (getcwd(buffer, MAXBUF ) == NULL )
+ return false;
+
+ chdir(work);
+
+ if (getcwd(otherdir, MAXBUF ) == NULL )
+ return false;
+
+ chdir(buffer);
+
+ size_t t = strlen(work);
+
+ if (strlen(otherdir) >= t)
+ {
+ otherdir[t] = '\0';
+
+ if (!strcmp(otherdir,work))
+ {
+ return true;
+ }
+
+ return false;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+std::string ServerConfig::GetFullProgDir(char** argv, int argc)
+{
+ char work[MAXBUF];
+ char buffer[MAXBUF];
+ char otherdir[MAXBUF];
+ int p;
+
+ strlcpy(work,argv[0],MAXBUF);
+ p = strlen(work);
+
+ // we just want the dir
+ while (*work)
+ {
+ if (work[p] == '/')
+ {
+ work[p] = '\0';
+ break;
+ }
+
+ work[p--] = '\0';
+ }
+
+ // Get the current working directory
+ if (getcwd(buffer, MAXBUF) == NULL)
+ return "";
+
+ chdir(work);
+
+ if (getcwd(otherdir, MAXBUF) == NULL)
+ return "";
+
+ chdir(buffer);
+ return otherdir;
+}
+
+InspIRCd* ServerConfig::GetInstance()
+{
+ return ServerInstance;
+}
+
projects / user / henk / code / inspircd.git / blobdiff