/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2018 linuxdaemon <linuxdaemon.irc@gmail.com>
+ * Copyright (C) 2013-2014, 2016-2020 Sadie Powell <sadie@witchery.services>
+ * Copyright (C) 2013 ChrisTX <xpipe@hotmail.de>
+ * Copyright (C) 2012-2014 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2012 Robby <robby@chatbelgie.be>
+ * Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
* Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
*
* This file is part of InspIRCd. InspIRCd is free software: you can
#include <fstream>
#include "configparser.h"
+enum ParseFlags
+{
+ // Legacy config parsing should be used.
+ FLAG_USE_COMPAT = 1,
+
+ // Executable includes are disabled.
+ FLAG_NO_EXEC = 2,
+
+ // All includes are disabled.
+ FLAG_NO_INC = 4,
+
+ // &env.FOO; is disabled.
+ FLAG_NO_ENV = 8,
+
+ // It's okay if an include doesn't exist.
+ FLAG_MISSING_OKAY = 16
+};
+
+// Represents the position within a config file.
+struct FilePosition
+{
+ // The name of the file which is being read.
+ std::string name;
+
+ // The line of the file that this position points to.
+ unsigned int line;
+
+ // The column of the file that this position points to.
+ unsigned int column;
+
+ FilePosition(const std::string& Name)
+ : name(Name)
+ , line(1)
+ , column(1)
+ {
+ }
+
+ /** Returns a string that represents this file position. */
+ std::string str()
+ {
+ return name + ":" + ConvToStr(line) + ":" + ConvToStr(column);
+ }
+};
+
+// RAII wrapper for FILE* which closes the file when it goes out of scope.
+class FileWrapper
+{
+ private:
+ // Whether this file handle should be closed with pclose.
+ bool close_with_pclose;
+
+ // The file handle which is being wrapped.
+ FILE* const file;
+
+ public:
+ FileWrapper(FILE* File, bool CloseWithPClose = false)
+ : close_with_pclose(CloseWithPClose)
+ , file(File)
+ {
+ }
+
+ // Operator which determines whether the file is open.
+ operator bool() { return (file != NULL); }
+
+ // Operator which retrieves the underlying FILE pointer.
+ operator FILE*() { return file; }
+
+ ~FileWrapper()
+ {
+ if (!file)
+ return;
+
+ if (close_with_pclose)
+ pclose(file);
+ else
+ fclose(file);
+ }
+};
+
+
struct Parser
{
ParseStack& stack;
int flags;
FILE* const file;
- fpos current;
- fpos last_tag;
+ FilePosition current;
+ FilePosition last_tag;
reference<ConfigTag> tag;
int ungot;
std::string mandatory_tag;
else if (ch == '\n')
{
current.line++;
- current.col = 0;
+ current.column = 0;
}
else
{
- current.col++;
+ current.column++;
}
return ch;
}
}
}
+ bool wordchar(char ch)
+ {
+ return isalnum(ch)
+ || ch == '-'
+ || ch == '.'
+ || ch == '_';
+ }
+
void nextword(std::string& rv)
{
int ch = next();
while (isspace(ch))
ch = next();
- while (isalnum(ch) || ch == '_'|| ch == '-')
+ while (wordchar(ch))
{
rv.push_back(ch);
ch = next();
unget(ch);
}
- bool kv(std::vector<KeyVal>* items, std::set<std::string>& seen)
+ bool kv(ConfigItems* items)
{
std::string key;
nextword(key);
while (1)
{
ch = next();
- if (isalnum(ch) || (varname.empty() && ch == '#'))
+ if (wordchar(ch) || (varname.empty() && ch == '#'))
varname.push_back(ch);
else if (ch == ';')
break;
throw CoreException("Invalid numeric character reference '&" + varname + ";'");
value.push_back(static_cast<char>(lvalue));
}
+ else if (varname.compare(0, 4, "env.") == 0)
+ {
+ if (flags & FLAG_NO_ENV)
+ throw CoreException("XML environment entity reference in file included with noenv=\"yes\"");
+
+ const char* envstr = getenv(varname.c_str() + 4);
+ if (!envstr)
+ throw CoreException("Undefined XML environment entity reference '&" + varname + ";'");
+
+ value.append(envstr);
+ }
else
{
- std::map<std::string, std::string>::iterator var = stack.vars.find(varname);
+ 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 == '"')
break;
- else
+ else if (ch != '\r')
value.push_back(ch);
}
- if (!seen.insert(key).second)
+ if (items->find(key) != items->end())
throw CoreException("Duplicate key '" + key + "' found");
- items->push_back(KeyVal(key, value));
+ (*items)[key] = value;
return true;
}
if (name.empty())
throw CoreException("Empty tag name");
- std::vector<KeyVal>* items;
- std::set<std::string> seen;
- tag = ConfigTag::create(name, current.filename, current.line, items);
+ ConfigItems* items;
+ tag = ConfigTag::create(name, current.name, current.line, items);
- while (kv(items, seen))
+ while (kv(items))
{
// Do nothing here (silences a GCC warning).
}
mandatory_tag.clear();
}
- if (name == "include")
+ if (stdalgo::string::equalsci(name, "include"))
{
stack.DoInclude(tag, flags);
}
- else if (name == "files")
+ else if (stdalgo::string::equalsci(name, "files"))
{
- for(std::vector<KeyVal>::iterator i = items->begin(); i != items->end(); i++)
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
{
stack.DoReadFile(i->first, i->second, flags, false);
}
}
- else if (name == "execfiles")
+ else if (stdalgo::string::equalsci(name, "execfiles"))
{
- for(std::vector<KeyVal>::iterator i = items->begin(); i != items->end(); i++)
+ for(ConfigItems::iterator i = items->begin(); i != items->end(); i++)
{
stack.DoReadFile(i->first, i->second, flags, true);
}
}
- else if (name == "define")
+ else if (stdalgo::string::equalsci(name, "define"))
{
if (flags & FLAG_USE_COMPAT)
throw CoreException("<define> tags may only be used in XML-style config (add <config format=\"xml\">)");
throw CoreException("Variable definition must include variable name");
stack.vars[varname] = value;
}
- else if (name == "config")
+ else if (stdalgo::string::equalsci(name, "config"))
{
std::string format = tag->getString("format");
- if (format == "xml")
+ if (stdalgo::string::equalsci(format, "xml"))
flags &= ~FLAG_USE_COMPAT;
- else if (format == "compat")
+ else if (stdalgo::string::equalsci(format, "compat"))
flags |= FLAG_USE_COMPAT;
else if (!format.empty())
throw CoreException("Unknown configuration format " + format);
break;
case 0xFE:
case 0xFF:
- stack.errstr << "Do not save your files as UTF-16; use ASCII!\n";
+ stack.errstr << "Do not save your files as UTF-16 or UTF-32, use UTF-8!\n";
+ /*@fallthrough@*/
default:
throw CoreException("Syntax error - start of tag expected");
}
{
if (tag->getBool("noinclude", false))
flags |= FLAG_NO_INC;
+
if (tag->getBool("noexec", false))
flags |= FLAG_NO_EXEC;
+
+ if (tag->getBool("noenv", false))
+ flags |= FLAG_NO_ENV;
+
+ if (tag->getBool("missingokay", false))
+ flags |= FLAG_MISSING_OKAY;
+ else
+ flags &= ~FLAG_MISSING_OKAY;
+
if (!ParseFile(ServerInstance->Config->Paths.PrependConfig(name), flags, mandatorytag))
throw CoreException("Included");
}
+ else if (tag->readString("directory", name))
+ {
+ if (tag->getBool("noinclude", false))
+ flags |= FLAG_NO_INC;
+ if (tag->getBool("noexec", false))
+ flags |= FLAG_NO_EXEC;
+ if (tag->getBool("noenv", false))
+ flags |= FLAG_NO_ENV;
+
+ const std::string includedir = ServerInstance->Config->Paths.PrependConfig(name);
+ std::vector<std::string> files;
+ if (!FileSystem::GetFileList(includedir, files, "*.conf"))
+ throw CoreException("Unable to read directory for include: " + includedir);
+
+ std::sort(files.begin(), files.end());
+ for (std::vector<std::string>::const_iterator iter = files.begin(); iter != files.end(); ++iter)
+ {
+ const std::string path = includedir + '/' + *iter;
+ if (!ParseFile(path, flags, mandatorytag))
+ throw CoreException("Included");
+ }
+ }
else if (tag->readString("executable", name))
{
if (flags & FLAG_NO_EXEC)
flags |= FLAG_NO_INC;
if (tag->getBool("noexec", true))
flags |= FLAG_NO_EXEC;
- if (!ParseExec(name, flags, mandatorytag))
+ if (tag->getBool("noenv", true))
+ flags |= FLAG_NO_ENV;
+
+ if (!ParseFile(name, flags, mandatorytag, true))
throw CoreException("Included");
}
}
}
}
-bool ParseStack::ParseFile(const std::string& path, int flags, const std::string& mandatory_tag)
+bool ParseStack::ParseFile(const std::string& path, int flags, const std::string& mandatory_tag, bool isexec)
{
- ServerInstance->Logs->Log("CONFIG", LOG_DEBUG, "Reading file %s", path.c_str());
- for (unsigned int t = 0; t < reading.size(); t++)
- {
- if (path == reading[t])
- {
- throw CoreException("File " + path + " is included recursively (looped inclusion)");
- }
- }
+ 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(fopen(path.c_str(), "r"));
+ FileWrapper file((isexec ? popen(path.c_str(), "r") : fopen(path.c_str(), "r")), isexec);
if (!file)
+ {
+ if (flags & FLAG_MISSING_OKAY)
+ return true;
+
throw CoreException("Could not read \"" + path + "\" for include");
+ }
reading.push_back(path);
Parser p(*this, flags, file, path, mandatory_tag);
return ok;
}
-bool ParseStack::ParseExec(const std::string& name, int flags, const std::string& mandatory_tag)
-{
- ServerInstance->Logs->Log("CONFIG", LOG_DEBUG, "Reading executable %s", name.c_str());
- for (unsigned int t = 0; t < reading.size(); t++)
- {
- if (std::string(name) == reading[t])
- {
- throw CoreException("Executable " + name + " 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"), true);
- if (!file)
- throw CoreException("Could not open executable \"" + name + "\" for include");
-
- reading.push_back(name);
- Parser p(*this, flags, file, name, 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;
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, const TR1NS::function<bool(const std::string&)>& validator)
{
- std::string res = def;
- readString(key, res);
+ std::string res;
+ if (!readString(key, res))
+ return def;
+
+ if (!validator(res))
+ {
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "WARNING: The value of <%s:%s> is not valid; value set to %s.",
+ tag.c_str(), key.c_str(), def.c_str());
+ return def;
+ }
return res;
}
+std::string ConfigTag::getString(const std::string& key, const std::string& def, size_t minlen, size_t maxlen)
+{
+ 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;
+}
+
+namespace
+{
+ /** Check for an invalid magnitude specifier. If one is found a warning is logged and the
+ * value is corrected (set to \p def).
+ * @param tag The tag name; used in the warning message.
+ * @param key The key name; used in the warning message.
+ * @param val The full value set in the config as a string.
+ * @param num The value to verify and modify if needed.
+ * @param def The default value, \p res will be set to this if \p tail does not contain a.
+ * valid magnitude specifier.
+ * @param tail The location in the config value at which the magnifier is located.
+ */
+ template <typename Numeric>
+ void CheckMagnitude(const std::string& tag, const std::string& key, const std::string& val, Numeric& num, Numeric def, const char* tail)
+ {
+ // If this is NULL then no magnitude specifier was given.
+ if (!*tail)
+ return;
+
+ switch (toupper(*tail))
+ {
+ case 'K':
+ num *= 1024;
+ return;
+
+ case 'M':
+ num *= 1024 * 1024;
+ return;
+
+ case 'G':
+ num *= 1024 * 1024 * 1024;
+ return;
+ }
+
+ const std::string message = "WARNING: <" + tag + ":" + key + "> value of " + val + " contains an invalid magnitude specifier '"
+ + tail + "'; value set to " + ConvToStr(def) + ".";
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, message);
+ num = def;
+ }
+
+ /** Check for an out of range value. If the value falls outside the boundaries a warning is
+ * logged and the value is corrected (set to \p def).
+ * @param tag The tag name; used in the warning message.
+ * @param key The key name; used in the warning message.
+ * @param num The value to verify and modify if needed.
+ * @param def The default value, \p res will be set to this if (min <= res <= max) doesn't hold true.
+ * @param min Minimum accepted value for \p res.
+ * @param max Maximum accepted value for \p res.
+ */
+ template <typename Numeric>
+ void CheckRange(const std::string& tag, const std::string& key, Numeric& num, Numeric def, Numeric min, Numeric max)
+ {
+ if (num >= min && num <= max)
+ return;
+
+ const std::string message = "WARNING: <" + tag + ":" + key + "> value of " + ConvToStr(num) + " is not between "
+ + ConvToStr(min) + " and " + ConvToStr(max) + "; value set to " + ConvToStr(def) + ".";
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, message);
+ num = def;
+ }
+}
+
long ConfigTag::getInt(const std::string &key, long def, long min, long max)
{
std::string result;
- if(!readString(key, result))
+ if(!readString(key, result) || result.empty())
return def;
const char* res_cstr = result.c_str();
long res = strtol(res_cstr, &res_tail, 0);
if (res_tail == res_cstr)
return def;
- switch (toupper(*res_tail))
- {
- case 'K':
- res = res * 1024;
- break;
- case 'M':
- res = res * 1024 * 1024;
- break;
- case 'G':
- res = res * 1024 * 1024 * 1024;
- break;
- }
- CheckRange(key, res, def, min, max);
+ CheckMagnitude(tag, key, result, res, def, res_tail);
+ CheckRange(tag, key, res, def, min, max);
return res;
}
-void ConfigTag::CheckRange(const std::string& key, long& res, long def, long min, long max)
+unsigned long ConfigTag::getUInt(const std::string& key, unsigned long def, unsigned long min, unsigned 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;
- }
+ std::string result;
+ if (!readString(key, result) || result.empty())
+ return def;
+
+ const char* res_cstr = result.c_str();
+ char* res_tail = NULL;
+ unsigned long res = strtoul(res_cstr, &res_tail, 0);
+ if (res_tail == res_cstr)
+ return def;
+
+ CheckMagnitude(tag, key, result, res, def, res_tail);
+ CheckRange(tag, key, res, def, min, max);
+ return res;
}
-long ConfigTag::getDuration(const std::string& key, long def, long min, long max)
+unsigned long ConfigTag::getDuration(const std::string& key, unsigned long def, unsigned long min, unsigned long max)
{
std::string duration;
- if (!readString(key, duration))
+ if (!readString(key, duration) || duration.empty())
return def;
- long ret = InspIRCd::Duration(duration);
- CheckRange(key, ret, def, min, max);
+ unsigned long ret;
+ if (!InspIRCd::Duration(duration, ret))
+ {
+ ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "Value of <" + tag + ":" + key + "> at " + getTagLocation() +
+ " is not a duration; value set to " + ConvToStr(def) + ".");
+ return def;
+ }
+
+ CheckRange(tag, key, ret, def, min, max);
return ret;
}
-double ConfigTag::getFloat(const std::string &key, double def)
+double ConfigTag::getFloat(const std::string& key, double def, double min, double max)
{
std::string result;
if (!readString(key, result))
return def;
- return strtod(result.c_str(), NULL);
+
+ double res = strtod(result.c_str(), NULL);
+ CheckRange(tag, key, res, def, min, max);
+ return res;
}
bool ConfigTag::getBool(const std::string &key, bool def)
{
std::string result;
- if(!readString(key, result))
+ if(!readString(key, result) || result.empty())
return def;
- if (result == "yes" || result == "true" || result == "1" || result == "on")
+ if (stdalgo::string::equalsci(result, "yes") || stdalgo::string::equalsci(result, "true") || stdalgo::string::equalsci(result, "on") || result == "1")
return true;
- if (result == "no" || result == "false" || result == "0" || result == "off")
+
+ if (stdalgo::string::equalsci(result, "no") || stdalgo::string::equalsci(result, "false") || stdalgo::string::equalsci(result, "off") || result == "0")
return false;
ServerInstance->Logs->Log("CONFIG", LOG_DEFAULT, "Value of <" + tag + ":" + key + "> at " + 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;
{
}
+OperInfo::OperInfo(const std::string& Name)
+ : name(Name)
+{
+}
+
std::string OperInfo::getConfig(const std::string& key)
{
std::string rv;
projects / user / henk / code / inspircd.git / blobdiff