*/
bool InitModule(ServerConfig* conf, const char*)
{
- old_module_names.clear();
+ old_module_names = conf->GetInstance()->Modules->GetAllModuleNames(0);
new_module_names.clear();
added_modules.clear();
removed_modules.clear();
- for (std::vector<std::string>::iterator t = conf->module_names.begin(); t != conf->module_names.end(); t++)
- {
- old_module_names.push_back(*t);
- }
return true;
}
}
}
-void ServerConfig::Read(bool bail, User* user)
+void ServerConfig::Read(bool bail, User* user, int pass)
{
+ int rem = 0, add = 0; /* Number of modules added, number of modules removed */
+
static char debug[MAXBUF]; /* Temporary buffer for debugging value */
static char maxkeep[MAXBUF]; /* Temporary buffer for WhoWasMaxKeep value */
static char hidemodes[MAXBUF]; /* Modes to not allow listing from users below halfop */
static char exemptchanops[MAXBUF]; /* Exempt channel ops from these modes */
static char announceinvites[MAXBUF]; /* options:announceinvites setting */
- int rem = 0, add = 0; /* Number of modules added, number of modules removed */
- std::ostringstream errstr; /* String stream containing the error output */
+ errstr.clear();
/* These tags MUST occur and must ONLY occur once in the config file */
static char* Once[] = { "server", "admin", "files", "power", "options", NULL };
{DT_IPADDRESS|DT_ALLOW_WILD,
DT_IPADDRESS|DT_ALLOW_WILD,
DT_CHARPTR, DT_INTEGER, DT_INTEGER, DT_INTEGER,
- DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER,
- DT_NOSPACES, DT_NOSPACES, DT_INTEGER, DT_INTEGER},
+ DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER, DT_INTEGER,
+ DT_NOSPACES, DT_NOSPACES, DT_INTEGER, DT_INTEGER},
InitConnect, DoConnect, DoneConnect},
{"uline",
{"No reason", "", NULL},
{DT_CHARPTR, DT_CHARPTR},
InitXLine, DoQLine, DoneConfItem},
-
+
{"badhost",
{"reason", "host", NULL},
{"No reason", "", NULL},
{"No reason", "", NULL},
{DT_CHARPTR, DT_CHARPTR},
InitXLine, DoELine, DoneELine},
-
+
{"type",
{"name", "classes", NULL},
{"", "", NULL},
{"", "", NULL},
{DT_NOSPACES, DT_CHARPTR},
InitClasses, DoClass, DoneClassesAndTypes},
-
+
{NULL,
{NULL},
{NULL},
NULL, NULL, NULL}
};
- include_stack.clear();
-
/* Load and parse the config file, if there are any errors then explode */
/* Make a copy here so if it fails then we can carry on running with an unaffected config */
- ConfigDataHash newconfig;
+ newconfig.clear();
- if (this->LoadConf(newconfig, ServerInstance->ConfigFileName, errstr))
+ if (this->LoadConf(newconfig, ServerInstance->ConfigFileName, errstr, pass))
{
/* If we succeeded, set the ircd config to the new one */
this->config_data = newconfig;
/* The stuff in here may throw CoreException, be sure we're in a position to catch it. */
try
{
- /* Check we dont have more than one of singular tags, or any of them missing
- */
- for (int Index = 0; Once[Index]; Index++)
- if (!CheckOnce(Once[Index]))
- return;
-
/* Read the values of all the tags which occur once or not at all, and call their callbacks.
*/
for (int Index = 0; Values[Index].tag; Index++)
ConfValue(this->config_data, Values[Index].tag, Values[Index].value, Values[Index].default_value, 0, item, MAXBUF, allow_newlines);
ValueItem vi(item);
-
+
if (!Values[Index].validation_function(this, Values[Index].tag, Values[Index].value, vi))
throw CoreException("One or more values in your configuration file failed to validate. Please see your ircd.log for more information.");
-
+
switch (Values[Index].datatype)
{
case DT_NOSPACES:
/* You don't want to know what happens if someones bad code sends us here. */
break;
}
-
/* We're done with this now */
delete Values[Index].val;
}
break;
}
}
-
- MultiValues[Index].validation_function(this, MultiValues[Index].tag, (char**)MultiValues[Index].items, vl, MultiValues[Index].datatype);
+ MultiValues[Index].validation_function(this, MultiValues[Index].tag, (char**)MultiValues[Index].items, vl, MultiValues[Index].datatype);
}
-
- MultiValues[Index].finish_function(this, MultiValues[Index].tag);
+ MultiValues[Index].finish_function(this, MultiValues[Index].tag);
}
}
return;
}
+ /** XXX END PASS **/
+ ServerInstance->Log(DEBUG,"End config pass %d", pass);
+
+ if (pass == 0)
+ {
+ /* FIRST PASS: Set up commands, load modules.
+ * We cannot gaurantee that all config is correct
+ * at this point
+ */
+
+ if (pass == 0)
+ {
+ if (isatty(0) && isatty(1) && isatty(2))
+ printf("Downloading configuration ");
+
+ TotalDownloaded = 0;
+ FileErrors = 0;
+ }
+
+ if (!ServerInstance->Res)
+ ServerInstance->Res = new DNS(ServerInstance);
+ /** Note: This is safe, the method checks for user == NULL */
+ ServerInstance->Parser->SetupCommandTable(user);
+ ServerInstance->Modules->LoadAll();
+ }
+ else
+ {
+ /* SECOND PASS: Call modules to read configs, finalize
+ * stuff. Check that we have at least the required number
+ * of whichever items. This is no longer done first.
+ */
+ ConfigReader* n = new ConfigReader(ServerInstance);
+ FOREACH_MOD(I_OnReadConfig,OnReadConfig(this, n));
+
+ for (int Index = 0; Once[Index]; Index++)
+ if (!CheckOnce(Once[Index]))
+ return;
+ }
+
// write once here, to try it out and make sure its ok
ServerInstance->WritePID(this->PID);
user->WriteServ("NOTICE %s :*** %d. IP: %s Port: %lu", user->nick, j, i->first.empty() ? "<all>" : i->first.c_str(), (unsigned long)i->second);
}
}
+ }
- if (!removed_modules.empty())
+ if (!removed_modules.empty())
+ {
+ for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
{
- for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
+ if (ServerInstance->Modules->Unload(removing->c_str()))
{
- if (ServerInstance->Modules->Unload(removing->c_str()))
- {
- ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
-
- if (user)
- user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
-
- rem++;
- }
- else
- {
- if (user)
- user->WriteServ("972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ServerInstance->Modules->LastError());
- }
+ ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
+ if (user)
+ user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
+ rem++;
+ }
+ else
+ {
+ if (user)
+ user->WriteServ("972 %s %s :%s",user->nick, removing->c_str(), ServerInstance->Modules->LastError().c_str());
}
}
+ }
- if (!added_modules.empty())
+ if (!added_modules.empty())
+ {
+ for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
{
- for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
+ /* Skip over modules that are aleready loaded for some reason */
+ if (ServerInstance->Modules->Find(*adding))
+ continue;
+
+ if (bail)
+ printf_c("[\033[1;32m*\033[0m] Loading module:\t\033[1;32m%s\033[0m\n", adding->c_str());
+
+ if (ServerInstance->Modules->Load(adding->c_str()))
{
- if (ServerInstance->Modules->Load(adding->c_str()))
- {
- ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
+ ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
+ if (user)
+ user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
- if (user)
- user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
+ add++;
+ }
+ else
+ {
+ if (user)
+ user->WriteServ("974 %s %s :%s",user->nick, adding->c_str(), ServerInstance->Modules->LastError().c_str());
- add++;
- }
- else
+ if (bail)
{
- if (user)
- user->WriteServ("974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ServerInstance->Modules->LastError());
+ printf_c("\n[\033[1;31m*\033[0m] %s\n\n", ServerInstance->Modules->LastError().c_str());
+ ServerInstance->Exit(EXIT_STATUS_MODULE);
}
}
}
-
- ServerInstance->Log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),(unsigned long)add,(unsigned long)added_modules.size());
}
- /** Note: This is safe, the method checks for user == NULL */
- ServerInstance->Parser->SetupCommandTable(user);
+ ServerInstance->Log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),(unsigned long)add,(unsigned long)added_modules.size());
if (user)
user->WriteServ("NOTICE %s :*** Successfully rehashed server.", user->nick);
ServerInstance->WriteOpers("*** Successfully rehashed server.");
}
-bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::ostringstream &errorstream)
+bool ServerConfig::Downloading()
+{
+ if (isatty(0) && isatty(1) && isatty(2))
+ {
+ printf(".");
+ fflush(stdout);
+ }
+
+ ServerInstance->Log(DEBUG, "ServerConfig::Downloading %d %d", TotalDownloaded, IncludedFiles.size());
+
+ /* Returns true if there are still files in the process of downloading */
+ return (TotalDownloaded < IncludedFiles.size());
+}
+
+void ServerConfig::Complete(const std::string &filename, bool error)
+{
+ ServerInstance->Log(DEBUG,"Flag complete: %s %d", filename.c_str(), error);
+ std::map<std::string, std::istream*>::iterator x = IncludedFiles.find(filename);
+
+ if (x != IncludedFiles.end())
+ {
+ if (error)
+ {
+ delete x->second;
+ x->second = NULL;
+ FileErrors++;
+ }
+ TotalDownloaded++;
+ }
+
+ return;
+}
+
+void ServerConfig::StartDownloads()
+{
+ ServerInstance->Log(DEBUG,"((((((((((((((((((((((((( StartDownloads() size=%d )))))))))))))))))))))))))))))))))))))", IncludedFiles.size());
+
+ /* Reads all local files into the IncludedFiles map, then initiates sockets for the remote ones */
+ for (std::map<std::string, std::istream*>::iterator x = IncludedFiles.begin(); x != IncludedFiles.end(); ++x)
+ {
+ if (CompletedFiles.find(x->first) != CompletedFiles.end())
+ continue;
+
+ ServerInstance->Log(DEBUG,"StartDownloads File: %s", x->first.c_str());
+
+ std::string file = x->first;
+ if ((file[0] == '/') || (file.substr(0, 7) == "file://"))
+ {
+ /* For file:// schema files, we use std::ifstream which is a derivative of std::istream.
+ * For all other file schemas, we use a std::stringstream.
+ */
+
+ /* Add our own ifstream */
+ std::ifstream* conf = new std::ifstream(file.c_str());
+ if (!conf->fail())
+ {
+ ServerInstance->Log(DEBUG,"file:// schema file %s loaded OK", file.c_str());
+ delete x->second;
+ x->second = conf;
+ }
+ else
+ {
+ delete x->second;
+ x->second = NULL;
+ FileErrors++;
+ }
+ TotalDownloaded++;
+ }
+ else
+ {
+ /* Modules handle these */
+ ServerInstance->Log(DEBUG,"Module-handled schema for %s", x->first.c_str());
+
+ /* For now, error it */
+ int MOD_RESULT = 0;
+ FOREACH_RESULT(I_OnDownloadFile, OnDownloadFile(file, x->second));
+ if (MOD_RESULT == 0)
+ {
+ /* No module claimed this file */
+ TotalDownloaded++;
+ FileErrors++;
+ delete x->second;
+ x->second = NULL;
+ }
+ }
+ CompletedFiles[x->first] = true;
+ }
+}
+
+bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::ostringstream &errorstream, int pass, std::istream *scan_for_includes_only)
{
- std::ifstream conf(filename);
std::string line;
+ std::istream* conf = NULL;
char ch;
long linenumber;
bool in_tag;
in_quote = false;
in_comment = false;
- /* Check if the file open failed first */
- if (!conf)
+ if (scan_for_includes_only)
{
- errorstream << "LoadConf: Couldn't open config file: " << filename << std::endl;
- return false;
+ ServerInstance->Log(DEBUG,"scan_for_includes_only set");
+ conf = scan_for_includes_only;
}
- /* Fix the chmod of the file to restrict it to the current user and group */
- chmod(filename,0600);
-
- for (unsigned int t = 0; t < include_stack.size(); t++)
+ if (std::string(filename) == CONFIG_FILE)
{
- if (std::string(filename) == include_stack[t])
+ if (!scan_for_includes_only)
{
- errorstream << "File " << filename << " is included recursively (looped inclusion)." << std::endl;
- return false;
+ conf = new std::ifstream(filename);
+ if (conf->fail())
+ {
+ errorstream << "File " << filename << " could not be opened." << std::endl;
+ return false;
+ }
+ }
+ }
+ else
+ {
+ std::map<std::string, std::istream*>::iterator x = IncludedFiles.find(filename);
+ if (x == IncludedFiles.end())
+ {
+ if (pass == 0)
+ {
+ ServerInstance->Log(DEBUG,"Push include file %s onto map", filename);
+ /* First pass, we insert the file into a map, and just return true */
+ IncludedFiles.insert(std::make_pair(filename,new std::stringstream));
+ return true;
+ }
+ else
+ {
+ /* Second pass, look for the file in the map */
+ ServerInstance->Log(DEBUG,"We are in the second pass, and %s is not in the map!", filename);
+ errorstream << "File " << filename << " could not be opened." << std::endl;
+ return false;
+ }
+ }
+ else
+ {
+ if (!scan_for_includes_only)
+ {
+ if (x->second)
+ conf = IncludedFiles.find(filename)->second;
+ else
+ {
+ errorstream << "File " << filename << " could not be opened." << std::endl;
+ return false;
+ }
+ }
}
}
- /* It's not already included, add it to the list of files we've loaded */
- include_stack.push_back(filename);
+ ServerInstance->Log(DEBUG,"Start to read conf %s %08lx", filename, conf);
/* Start reading characters... */
- while (conf.get(ch))
+ while (conf->get(ch))
{
/*
if ((character_count++ < 2) && (ch == '\xFF' || ch == '\xFE'))
{
errorstream << "File " << filename << " cannot be read, as it is encoded in braindead UTF-16. Save your file as plain ASCII!" << std::endl;
+ if (!scan_for_includes_only)
+ delete conf;
return false;
}
{
line += ch;
char real_character;
- if (conf.get(real_character))
+ if (conf->get(real_character))
{
if (real_character == 'n')
real_character = '\n';
else
{
errorstream << "End of file after a \\, what did you want to escape?: " << filename << ":" << linenumber << std::endl;
+ if (!scan_for_includes_only)
+ delete conf;
return false;
}
}
if (!in_quote)
{
errorstream << "Got another opening < when the first one wasn't closed: " << filename << ":" << linenumber << std::endl;
+ if (!scan_for_includes_only)
+ delete conf;
return false;
}
}
if (in_quote)
{
errorstream << "We're in a quote but outside a tag, interesting. " << filename << ":" << linenumber << std::endl;
+ if (!scan_for_includes_only)
+ delete conf;
return false;
}
else
* LoadConf() and load the included config into the same ConfigDataHash
*/
- if (!this->ParseLine(target, line, linenumber, errorstream))
+ if (!this->ParseLine(target, line, linenumber, errorstream, pass, scan_for_includes_only))
+ {
+ if (!scan_for_includes_only)
+ delete conf;
return false;
+ }
line.clear();
}
else
{
errorstream << "Got a closing > when we weren't inside a tag: " << filename << ":" << linenumber << std::endl;
+ if (!scan_for_includes_only)
+ delete conf;
return false;
}
}
is a newline missing from the end of the file: " << filename << ":" << linenumber << std::endl;
}
+ if (!scan_for_includes_only)
+ delete conf;
return true;
}
-bool ServerConfig::LoadConf(ConfigDataHash &target, const std::string &filename, std::ostringstream &errorstream)
+bool ServerConfig::LoadConf(ConfigDataHash &target, const std::string &filename, std::ostringstream &errorstream, int pass, std::istream* scan_for_includs_only)
{
- return this->LoadConf(target, filename.c_str(), errorstream);
+ return this->LoadConf(target, filename.c_str(), errorstream, pass, scan_for_includs_only);
}
-bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &linenumber, std::ostringstream &errorstream)
+bool ServerConfig::ParseLine(ConfigDataHash &target, std::string &line, long &linenumber, std::ostringstream &errorstream, int pass, std::istream* scan_for_includes_only)
{
std::string tagname;
std::string current_key;
else
{
/* Leaving quotes, we have the value */
- results.push_back(KeyVal(current_key, current_value));
+ if (!scan_for_includes_only)
+ results.push_back(KeyVal(current_key, current_value));
// std::cout << "<" << tagname << ":" << current_key << "> " << current_value << std::endl;
got_key = false;
if ((tagname == "include") && (current_key == "file"))
- {
- if (!this->DoInclude(target, current_value, errorstream))
+ {
+ if (!this->DoInclude(target, current_value, errorstream, pass, scan_for_includes_only))
return false;
}
}
/* Finished parsing the tag, add it to the config hash */
- target.insert(std::pair<std::string, KeyValList > (tagname, results));
+ if (!scan_for_includes_only)
+ target.insert(std::pair<std::string, KeyValList > (tagname, results));
return true;
}
-bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream)
+bool ServerConfig::DoInclude(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream, int pass, std::istream* scan_for_includes_only)
{
std::string confpath;
std::string newfile;
std::replace(newfile.begin(),newfile.end(),'\\','/');
std::replace(confpath.begin(),confpath.end(),'\\','/');
- if (newfile[0] != '/')
+ if ((newfile[0] != '/') && (newfile.find("://") == std::string::npos))
{
if((pos = confpath.rfind("/")) != std::string::npos)
{
}
}
- return LoadConf(target, newfile, errorstream);
+ return LoadConf(target, newfile, errorstream, pass, scan_for_includes_only);
}
bool ServerConfig::ConfValue(ConfigDataHash &target, const char* tag, const char* var, int index, char* result, int length, bool allow_linefeeds)
projects / user / henk / code / inspircd.git / blobdiff