#include "userprocess.h"
#include "xline.h"
-extern ServerConfig *Config;
extern InspIRCd* ServerInstance;
extern time_t TIME;
*CustomVersion = *motd = *rules = *PrefixQuit = *DieValue = *DNSServer = '\0';
*OperOnlyStats = *ModPath = *MyExecutable = *DisabledCommands = *PID = '\0';
log_file = NULL;
- forcedebug = OperSpyWhois = nofork = HideBans = HideSplits = false;
+ NoUserDns = forcedebug = OperSpyWhois = nofork = HideBans = HideSplits = false;
writelog = AllowHalfop = true;
dns_timeout = DieDelay = 5;
MaxTargets = 20;
bool ServerConfig::CheckOnce(char* tag, bool bail, userrec* user)
{
- int count = ConfValueEnum(Config->config_data, tag);
+ int count = ConfValueEnum(this->config_data, tag);
if (count > 1)
{
{
if (user)
{
- WriteServ(user->fd,"There were errors in your configuration:");
- WriteServ(user->fd,"You have more than one <%s> tag, this is not permitted.\n",tag);
+ user->WriteServ("There were errors in your configuration:");
+ user->WriteServ("You have more than one <%s> tag, this is not permitted.\n",tag);
}
else
{
{
if (user)
{
- WriteServ(user->fd,"There were errors in your configuration:");
- WriteServ(user->fd,"You have not defined a <%s> tag, this is required.",tag);
+ user->WriteServ("There were errors in your configuration:");
+ user->WriteServ("You have not defined a <%s> tag, this is required.",tag);
}
else
{
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);
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))
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))
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)
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)
return true;
}
-bool ValidateDnsServer(const char* tag, const char* value, void* data)
+bool InitializeDisabledCommands(const char* data, InspIRCd* ServerInstance)
+{
+ std::stringstream dcmds(data);
+ std::string thiscmd;
+
+ /* Enable everything first */
+ for (nspace::hash_map<std::string,command_t*>::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)
+ {
+ 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());
+ cm->second->Disable(true);
+ }
+ }
+ return true;
+}
+
+bool ValidateDnsServer(ServerConfig* conf, const char* tag, const char* value, void* data)
{
char* x = (char*)data;
if (!*x)
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,'.'))
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 ((!Config->NetBufferSize) || (Config->NetBufferSize > 65535) || (Config->NetBufferSize < 1024))
+ if ((!ServerInstance->Config->NetBufferSize) || (ServerInstance->Config->NetBufferSize > 65535) || (ServerInstance->Config->NetBufferSize < 1024))
{
log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
- Config->NetBufferSize = 10240;
+ ServerInstance->Config->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 ((!Config->MaxWhoResults) || (Config->MaxWhoResults > 65535) || (Config->MaxWhoResults < 1))
+ if ((!ServerInstance->Config->MaxWhoResults) || (ServerInstance->Config->MaxWhoResults > 65535) || (ServerInstance->Config->MaxWhoResults < 1))
{
log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
- Config->MaxWhoResults = 128;
+ ServerInstance->Config->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;
- Config->LogLevel = DEFAULT;
+ ServerInstance->Config->LogLevel = DEFAULT;
if (!strcmp(dbg,"debug"))
{
- Config->LogLevel = DEBUG;
- Config->debugging = 1;
+ ServerInstance->Config->LogLevel = DEBUG;
+ ServerInstance->Config->debugging = 1;
}
else if (!strcmp(dbg,"verbose"))
- Config->LogLevel = VERBOSE;
+ ServerInstance->Config->LogLevel = VERBOSE;
else if (!strcmp(dbg,"default"))
- Config->LogLevel = DEFAULT;
+ ServerInstance->Config->LogLevel = DEFAULT;
else if (!strcmp(dbg,"sparse"))
- Config->LogLevel = SPARSE;
+ ServerInstance->Config->LogLevel = SPARSE;
else if (!strcmp(dbg,"none"))
- Config->LogLevel = NONE;
+ ServerInstance->Config->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(Config->MOTD,Config->motd);
+ conf->ReadFile(ServerInstance->Config->MOTD,ServerInstance->Config->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(Config->RULES,Config->rules);
+ conf->ReadFile(ServerInstance->Config->RULES,ServerInstance->Config->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...");
- Config->Classes.clear();
+ ServerInstance->Config->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.registration_timeout = 90;
if (c.pingtime == 0)
c.pingtime = 120;
- Config->Classes.push_back(c);
+ ServerInstance->Config->Classes.push_back(c);
}
else
{
c.host = deny;
c.type = CC_DENY;
- Config->Classes.push_back(c);
+ ServerInstance->Config->Classes.push_back(c);
log(DEBUG,"Read connect class type DENY, host=%s",deny);
}
/* 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);
return true;
/* Callback called before processing the first <uline> tag
*/
-bool InitULine(const char* tag)
+bool InitULine(ServerConfig* conf, const char* tag)
{
- Config->ulines.clear();
+ ServerInstance->Config->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);
- Config->ulines.push_back(server);
+ ServerInstance->Config->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 = Config->module_names.begin(); t != Config->module_names.end(); t++)
+ for (std::vector<std::string>::iterator t = ServerInstance->Config->module_names.begin(); t != ServerInstance->Config->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)
{
- Config->maxbans.clear();
+ ServerInstance->Config->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];
- Config->maxbans[channel] = *limit;
+ ServerInstance->Config->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;
}
{"options", "hidewhois", &this->HideWhoisServer, DT_CHARPTR, NoValidation},
{"options", "operspywhois", &this->OperSpyWhois, DT_BOOLEAN, NoValidation},
{"options", "tempdir", &this->TempDir, DT_CHARPTR, ValidateTempDir},
+ {"options", "nouserdns", &this->NoUserDns, DT_BOOLEAN, NoValidation},
+ {"options", "syntaxhints", &this->SyntaxHints, 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 */
- Config->config_data = newconfig;
+ this->config_data = newconfig;
/* int c = 1;
std::string last;
unsigned int prefixlen;
start = 0;
- /* ":Config->ServerName NOTICE user->nick :" */
- prefixlen = strlen(Config->ServerName) + strlen(user->nick) + 11;
+ /* ":ServerInstance->Config->ServerName NOTICE user->nick :" */
+ prefixlen = strlen(this->ServerName) + strlen(user->nick) + 11;
if (user)
{
- WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
+ user->WriteServ("NOTICE %s :There were errors in the configuration file:",user->nick);
while(start < errors.length())
{
- WriteServ(user->fd, "NOTICE %s :%s",user->nick, errors.substr(start, 510 - prefixlen).c_str());
+ user->WriteServ("NOTICE %s :%s",user->nick, errors.substr(start, 510 - prefixlen).c_str());
start += 510 - prefixlen;
}
}
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
delete[] data[n];
// write once here, to try it out and make sure its ok
- ServerInstance->WritePID(Config->PID);
+ ServerInstance->WritePID(this->PID);
log(DEFAULT,"Done reading configuration file, InspIRCd is now starting.");
WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
if (user)
- WriteServ(user->fd,"973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
+ user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
rem++;
}
else
{
if (user)
- WriteServ(user->fd,"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->ModuleError());
}
}
WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
if (user)
- WriteServ(user->fd,"975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
+ user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
add++;
}
else
{
if (user)
- WriteServ(user->fd,"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->ModuleError());
}
}
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();
+ file = fopen(fname,"r");
+
+ if (file)
+ {
+ while (!feof(file))
+ {
+ fgets(linebuf,sizeof(linebuf),file);
+ linebuf[strlen(linebuf)-1]='\0';
+
+ if (!*linebuf)
+ {
+ strcpy(linebuf," ");
+ }
+
+ if (!feof(file))
+ {
+ F.push_back(linebuf);
+ }
+ }
+
+ fclose(file);
+ }
+ else
+ return false;
+
+ return true;
+}
+
projects / user / henk / code / inspircd.git / blobdiff