-/* +------------------------------------+
- * | Inspire Internet Relay Chat Daemon |
- * +------------------------------------+
+/*
+ * InspIRCd -- Internet Relay Chat Daemon
*
- * InspIRCd: (C) 2002-2009 InspIRCd Development Team
- * See: http://wiki.inspircd.org/Credits
+ * Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
*
- * This program is free but copyrighted software; see
- * the file COPYING for details.
+ * This file is part of InspIRCd. InspIRCd is free software: you can
+ * redistribute it and/or modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation, version 2.
*
- * ---------------------------------------------------
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+
#include "inspircd.h"
#include <fstream>
#include "configparser.h"
struct Parser
{
ParseStack& stack;
- const int flags;
+ int flags;
FILE* const file;
fpos current;
fpos last_tag;
reference<ConfigTag> tag;
int ungot;
+ std::string mandatory_tag;
- Parser(ParseStack& me, int myflags, FILE* conf, const std::string& name)
- : stack(me), flags(myflags), file(conf), current(name), last_tag(name), ungot(-1)
+ Parser(ParseStack& me, int myflags, FILE* conf, const std::string& name, const std::string& mandatorytag)
+ : stack(me), flags(myflags), file(conf), current(name), last_tag(name), ungot(-1), mandatory_tag(mandatorytag)
{ }
int next(bool eof_ok = false)
int ch = next();
while (isspace(ch))
ch = next();
- while (isalnum(ch) || ch == '_')
+ while (isalnum(ch) || ch == '_'|| ch == '-')
{
rv.push_back(ch);
ch = next();
unget(ch);
}
- bool kv(std::vector<KeyVal>* items)
+ bool kv(ConfigItems* items)
{
std::string key;
nextword(key);
while (1)
{
ch = next();
- if (ch == '&')
+ if (ch == '&' && !(flags & FLAG_USE_COMPAT))
{
std::string varname;
while (1)
{
ch = next();
- if (isalnum(ch))
+ if (isalnum(ch) || (varname.empty() && ch == '#'))
varname.push_back(ch);
else if (ch == ';')
break;
throw CoreException("Parse error");
}
}
- std::map<std::string, std::string>::iterator var = stack.vars.find(varname);
- if (var == stack.vars.end())
- throw CoreException("Undefined XML entity reference '&" + varname + ";'");
- value.append(var->second);
+ if (varname.empty())
+ throw CoreException("Empty XML entity reference");
+ else if (varname[0] == '#' && (varname.size() == 1 || (varname.size() == 2 && varname[1] == 'x')))
+ throw CoreException("Empty numeric character reference");
+ else if (varname[0] == '#')
+ {
+ const char* cvarname = varname.c_str();
+ char* endptr;
+ unsigned long lvalue;
+ if (cvarname[1] == 'x')
+ lvalue = strtoul(cvarname + 2, &endptr, 16);
+ else
+ lvalue = strtoul(cvarname + 1, &endptr, 10);
+ if (*endptr != '\0' || lvalue > 255)
+ throw CoreException("Invalid numeric character reference '&" + varname + ";'");
+ value.push_back(static_cast<char>(lvalue));
+ }
+ else
+ {
+ insp::flat_map<std::string, std::string>::iterator var = stack.vars.find(varname);
+ if (var == stack.vars.end())
+ throw CoreException("Undefined XML entity reference '&" + varname + ";'");
+ value.append(var->second);
+ }
+ }
+ else if (ch == '\\' && (flags & FLAG_USE_COMPAT))
+ {
+ int esc = next();
+ if (esc == 'n')
+ value.push_back('\n');
+ else if (isalpha(esc))
+ throw CoreException("Unknown escape character \\" + std::string(1, esc));
+ else
+ value.push_back(esc);
}
else if (ch == '"')
break;
- value.push_back(ch);
+ else if (ch != '\r')
+ value.push_back(ch);
}
- items->push_back(KeyVal(key, value));
+
+ if (items->find(key) != items->end())
+ throw CoreException("Duplicate key '" + key + "' found");
+
+ (*items)[key] = value;
return true;
}
if (name.empty())
throw CoreException("Empty tag name");
- std::vector<KeyVal>* items;
+ ConfigItems* items;
tag = ConfigTag::create(name, current.filename, current.line, items);
- while (kv(items));
+ while (kv(items))
+ {
+ // Do nothing here (silences a GCC warning).
+ }
+
+ if (name == mandatory_tag)
+ {
+ // Found the mandatory tag
+ mandatory_tag.clear();
+ }
if (name == "include")
{
stack.DoInclude(tag, flags);
}
+ else if (name == "files")
+ {
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
+ {
+ stack.DoReadFile(i->first, i->second, flags, false);
+ }
+ }
+ else if (name == "execfiles")
+ {
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
+ {
+ stack.DoReadFile(i->first, i->second, flags, true);
+ }
+ }
else if (name == "define")
{
+ if (flags & FLAG_USE_COMPAT)
+ throw CoreException("<define> tags may only be used in XML-style config (add <config format=\"xml\">)");
std::string varname = tag->getString("name");
std::string value = tag->getString("value");
if (varname.empty())
throw CoreException("Variable definition must include variable name");
stack.vars[varname] = value;
}
+ else if (name == "config")
+ {
+ std::string format = tag->getString("format");
+ if (format == "xml")
+ flags &= ~FLAG_USE_COMPAT;
+ else if (format == "compat")
+ flags |= FLAG_USE_COMPAT;
+ else if (!format.empty())
+ throw CoreException("Unknown configuration format " + format);
+ }
else
{
stack.output.insert(std::make_pair(name, tag));
{
case EOF:
// this is the one place where an EOF is not an error
+ if (!mandatory_tag.empty())
+ throw CoreException("Mandatory tag \"" + mandatory_tag + "\" not found");
return true;
case '#':
comment();
{
if (flags & FLAG_NO_INC)
throw CoreException("Invalid <include> tag in file included with noinclude=\"yes\"");
+
+ std::string mandatorytag;
+ tag->readString("mandatorytag", mandatorytag);
+
std::string name;
if (tag->readString("file", name))
{
flags |= FLAG_NO_INC;
if (tag->getBool("noexec", false))
flags |= FLAG_NO_EXEC;
- if (!ParseFile(name, flags))
+ if (!ParseFile(ServerInstance->Config->Paths.PrependConfig(name), flags, mandatorytag))
throw CoreException("Included");
}
else if (tag->readString("executable", name))
flags |= FLAG_NO_INC;
if (tag->getBool("noexec", true))
flags |= FLAG_NO_EXEC;
- if (!ParseExec(name, flags))
+ if (!ParseFile(name, flags, mandatorytag, true))
throw CoreException("Included");
}
}
-bool ParseStack::ParseFile(const std::string& name, int flags)
+void ParseStack::DoReadFile(const std::string& key, const std::string& name, int flags, bool exec)
{
- ServerInstance->Logs->Log("CONFIG", DEBUG, "Reading file %s", name.c_str());
- for (unsigned int t = 0; t < reading.size(); t++)
- {
- if (std::string(name) == reading[t])
- {
- throw CoreException("File " + name + " is included recursively (looped inclusion)");
- }
- }
-
- /* It's not already included, add it to the list of files we've loaded */
+ if (flags & FLAG_NO_INC)
+ throw CoreException("Invalid <files> tag in file included with noinclude=\"yes\"");
+ if (exec && (flags & FLAG_NO_EXEC))
+ throw CoreException("Invalid <execfiles> tag in file included with noexec=\"yes\"");
- FileWrapper file(fopen(name.c_str(), "r"));
+ std::string path = ServerInstance->Config->Paths.PrependConfig(name);
+ FileWrapper file(exec ? popen(name.c_str(), "r") : fopen(path.c_str(), "r"), exec);
if (!file)
- throw CoreException("Could not read \"" + name + "\" for include");
+ throw CoreException("Could not read \"" + path + "\" for \"" + key + "\" file");
- reading.push_back(name);
- Parser p(*this, flags, file, name);
- bool ok = p.outer_parse();
- reading.pop_back();
- return ok;
-}
+ file_cache& cache = FilesOutput[key];
+ cache.clear();
-bool ParseStack::ParseExec(const std::string& name, int flags)
-{
- ServerInstance->Logs->Log("CONFIG", DEBUG, "Reading executable %s", name.c_str());
- for (unsigned int t = 0; t < reading.size(); t++)
+ char linebuf[5120];
+ while (fgets(linebuf, sizeof(linebuf), file))
{
- if (std::string(name) == reading[t])
+ size_t len = strlen(linebuf);
+ if (len)
{
- throw CoreException("Executable " + name + " is included recursively (looped inclusion)");
+ if (linebuf[len-1] == '\n')
+ len--;
+ cache.push_back(std::string(linebuf, len));
}
}
+}
+
+bool ParseStack::ParseFile(const std::string& path, int flags, const std::string& mandatory_tag, bool isexec)
+{
+ ServerInstance->Logs->Log("CONFIG", LOG_DEBUG, "Reading (isexec=%d) %s", isexec, path.c_str());
+ if (stdalgo::isin(reading, path))
+ throw CoreException((isexec ? "Executable " : "File ") + path + " is included recursively (looped inclusion)");
/* It's not already included, add it to the list of files we've loaded */
- FileWrapper file(popen(name.c_str(), "r"));
+ FileWrapper file((isexec ? popen(path.c_str(), "r") : fopen(path.c_str(), "r")), isexec);
if (!file)
- throw CoreException("Could not open executable \"" + name + "\" for include");
+ throw CoreException("Could not read \"" + path + "\" for include");
- reading.push_back(name);
- Parser p(*this, flags, file, name);
+ reading.push_back(path);
+ Parser p(*this, flags, file, path, mandatory_tag);
bool ok = p.outer_parse();
reading.pop_back();
return ok;
bool ConfigTag::readString(const std::string& key, std::string& value, bool allow_lf)
{
- if (!this)
- return false;
- for(std::vector<KeyVal>::iterator j = items.begin(); j != items.end(); ++j)
+ for(ConfigItems::iterator j = items.begin(); j != items.end(); ++j)
{
if(j->first != key)
continue;
value = j->second;
if (!allow_lf && (value.find('\n') != std::string::npos))
{
- ServerInstance->Logs->Log("CONFIG",DEFAULT, "Value of <" + tag + ":" + key + "> at " + getTagLocation() +
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "Value of <" + tag + ":" + key + "> at " + getTagLocation() +
" contains a linefeed, and linefeeds in this value are not permitted -- stripped to spaces.");
for (std::string::iterator n = value.begin(); n != value.end(); n++)
if (*n == '\n')
return false;
}
-std::string ConfigTag::getString(const std::string& key, const std::string& def)
+std::string ConfigTag::getString(const std::string& key, const std::string& def, size_t minlen, size_t maxlen)
{
- std::string res = def;
- readString(key, res);
+ std::string res;
+ if (!readString(key, res))
+ return def;
+
+ if (res.length() < minlen || res.length() > maxlen)
+ {
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "WARNING: The length of <%s:%s> is not between %ld and %ld; value set to %s.",
+ tag.c_str(), key.c_str(), minlen, maxlen, def.c_str());
+ return def;
+ }
return res;
}
-long ConfigTag::getInt(const std::string &key, long def)
+long ConfigTag::getInt(const std::string &key, long def, long min, long max)
{
std::string result;
if(!readString(key, result))
switch (toupper(*res_tail))
{
case 'K':
- res= res* 1024;
+ res = res * 1024;
break;
case 'M':
- res= res* 1024 * 1024;
+ res = res * 1024 * 1024;
break;
case 'G':
- res= res* 1024 * 1024 * 1024;
+ res = res * 1024 * 1024 * 1024;
break;
}
+
+ CheckRange(key, res, def, min, max);
return res;
}
+void ConfigTag::CheckRange(const std::string& key, long& res, long def, long min, long max)
+{
+ if (res < min || res > max)
+ {
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "WARNING: <%s:%s> value of %ld is not between %ld and %ld; set to %ld.",
+ tag.c_str(), key.c_str(), res, min, max, def);
+ res = def;
+ }
+}
+
+long ConfigTag::getDuration(const std::string& key, long def, long min, long max)
+{
+ std::string duration;
+ if (!readString(key, duration))
+ return def;
+
+ long ret = InspIRCd::Duration(duration);
+ CheckRange(key, ret, def, min, max);
+ return ret;
+}
+
double ConfigTag::getFloat(const std::string &key, double def)
{
std::string result;
if(!readString(key, result))
return def;
- return (result == "yes" || result == "true" || result == "1" || result == "on");
+ if (result == "yes" || result == "true" || result == "1" || result == "on")
+ return true;
+ if (result == "no" || result == "false" || result == "0" || result == "off")
+ return false;
+
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "Value of <" + tag + ":" + key + "> at " + getTagLocation() +
+ " is not valid, ignoring");
+ return def;
}
std::string ConfigTag::getTagLocation()
return src_name + ":" + ConvToStr(src_line);
}
-ConfigTag* ConfigTag::create(const std::string& Tag, const std::string& file, int line, std::vector<KeyVal>*&items)
+ConfigTag* ConfigTag::create(const std::string& Tag, const std::string& file, int line, ConfigItems*& Items)
{
ConfigTag* rv = new ConfigTag(Tag, file, line);
- items = &rv->items;
+ Items = &rv->items;
return rv;
}
{
}
+OperInfo::OperInfo(const std::string& Name)
+ : name(Name)
+{
+}
+
std::string OperInfo::getConfig(const std::string& key)
{
std::string rv;