]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/configreader.cpp
Now wont even try to read an empty file
[user/henk/code/inspircd.git] / src / configreader.cpp
index 7741b9d9f79f04d65caf9e4d1b10a712212a3340..f767eae72efe886d62f8f27d2c8f808de8f0845d 100644 (file)
@@ -17,6 +17,7 @@
 #include "inspircd.h"
 #include "xline.h"
 #include "exitcodes.h"
+#include "commands/cmd_whowas.h"
 
 std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
 
@@ -77,7 +78,6 @@ bool ServerConfig::AddIOHook(Module* iomod, InspSocket* is)
 {
        if (!GetIOHook(is))
        {
-               ServerInstance->Log(DEBUG,"Hooked inspsocket %08x", is);
                SocketIOHookModule[is] = iomod;
                is->IsIOHooked = true;
                return true;
@@ -131,9 +131,12 @@ void ServerConfig::Update005()
                        token_counter = 0;
                }
        }
-       char buf[MAXBUF];
-       snprintf(buf, MAXBUF, "%s:are supported by this server", line5.c_str());
-       isupport.push_back(buf);
+       if (!line5.empty())
+       {
+               char buf[MAXBUF];
+               snprintf(buf, MAXBUF, "%s:are supported by this server", line5.c_str());
+               isupport.push_back(buf);
+       }
 }
 
 void ServerConfig::Send005(userrec* user)
@@ -195,7 +198,6 @@ bool ServerConfig::CheckOnce(char* tag, bool bail, userrec* user)
 
 bool NoValidation(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
 {
-       conf->GetInstance()->Log(DEBUG,"No validation for <%s:%s>",tag,value);
        return true;
 }
 
@@ -223,15 +225,6 @@ bool ValidateMaxConn(ServerConfig* conf, const char* tag, const char* value, Val
 {
        if (data.GetInteger() > SOMAXCONN)
                conf->GetInstance()->Log(DEFAULT,"WARNING: <options:somaxconn> value may be higher than the system-defined SOMAXCONN value!");
-       if (!data.GetInteger())
-               data.Set(SOMAXCONN);
-       return true;
-}
-
-bool ValidateDnsTimeout(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
-{
-       if (!data.GetInteger())
-               data.Set(5);
        return true;
 }
 
@@ -250,7 +243,6 @@ bool InitializeDisabledCommands(const char* data, InspIRCd* ServerInstance)
                nspace::hash_map<std::string,command_t*>::iterator cm = ServerInstance->Parser->cmdlist.find(thiscmd);
                if (cm != ServerInstance->Parser->cmdlist.end())
                {
-                       ServerInstance->Log(DEBUG,"Disabling command '%s'",cm->second->command.c_str());
                        cm->second->Disable(true);
                }
        }
@@ -295,14 +287,6 @@ bool ValidateDnsServer(ServerConfig* conf, const char* tag, const char* value, V
        return true;
 }
 
-bool ValidateModPath(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
-{
-       if (!*(data.GetString()))
-               data.Set(MOD_PATH);
-       return true;
-}
-
-
 bool ValidateServerName(ServerConfig* conf, const char* tag, const char* value, ValueItem &data)
 {
        if (!strchr(data.GetString(),'.'))
@@ -382,8 +366,14 @@ bool ValidateWhoWas(ServerConfig* conf, const char* tag, const char* value, Valu
                conf->WhoWasMaxKeep = 3600;
                conf->GetInstance()->Log(DEFAULT,"WARNING: <whowas:maxkeep> value less than 3600, setting to default 3600");
        }
-       conf->GetInstance()->Log(DEBUG,"whowas:groupsize:%d maxgroups:%d maxkeep:%d",conf->WhoWasGroupSize,conf->WhoWasMaxGroups,conf->WhoWasMaxKeep);
-       irc::whowas::PruneWhoWas(conf->GetInstance(), conf->GetInstance()->Time());
+
+       command_t* whowas_command = conf->GetInstance()->Parser->GetHandler("WHOWAS");
+       if (whowas_command)
+       {
+               std::deque<classbase*> params;
+               whowas_command->HandleInternal(WHOWAS_PRUNE, params);
+       }
+
        return true;
 }
 
@@ -431,7 +421,6 @@ bool DoConnect(ServerConfig* conf, const char* tag, char** entries, ValueList &v
  */
 bool DoneConnect(ServerConfig* conf, const char* tag)
 {
-       conf->GetInstance()->Log(DEBUG,"DoneConnect called for tag: %s",tag);
        return true;
 }
 
@@ -448,7 +437,6 @@ bool InitULine(ServerConfig* conf, const char* tag)
 bool DoULine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types)
 {
        const char* server = values[0].GetString();
-       conf->GetInstance()->Log(DEBUG,"Read ULINE '%s'",server);
        conf->ulines.push_back(server);
        return true;
 }
@@ -595,43 +583,43 @@ void ServerConfig::Read(bool bail, userrec* user)
 
        /* These tags can occur ONCE or not at all */
        InitialConfig Values[] = {
-               {"options",     "softlimit",    "",             new ValueContainerUInt (&this->SoftLimit),              DT_INTEGER, ValidateSoftLimit},
-               {"options",     "somaxconn",    "",             new ValueContainerInt  (&this->MaxConn),                DT_INTEGER, ValidateMaxConn},
-               {"server",      "name",         "",             new ValueContainerChar (this->ServerName),              DT_CHARPTR, ValidateServerName},
-               {"server",      "description",  "",             new ValueContainerChar (this->ServerDesc),              DT_CHARPTR, NoValidation},
-               {"server",      "network",      "",             new ValueContainerChar (this->Network),                 DT_CHARPTR, NoValidation},
-               {"admin",       "name",         "",             new ValueContainerChar (this->AdminName),               DT_CHARPTR, NoValidation},
-               {"admin",       "email",        "",             new ValueContainerChar (this->AdminEmail),              DT_CHARPTR, NoValidation},
-               {"admin",       "nick",         "",             new ValueContainerChar (this->AdminNick),               DT_CHARPTR, NoValidation},
-               {"files",       "motd",         "",             new ValueContainerChar (this->motd),                    DT_CHARPTR, ValidateMotd},
-               {"files",       "rules",        "",             new ValueContainerChar (this->rules),                   DT_CHARPTR, ValidateRules},
-               {"power",       "diepass",      "",             new ValueContainerChar (this->diepass),                 DT_CHARPTR, NoValidation},      
-               {"power",       "pause",        "",             new ValueContainerInt  (&this->DieDelay),               DT_INTEGER, NoValidation},
-               {"power",       "restartpass",  "",             new ValueContainerChar (this->restartpass),             DT_CHARPTR, NoValidation},
-               {"options",     "prefixquit",   "",             new ValueContainerChar (this->PrefixQuit),              DT_CHARPTR, NoValidation},
-               {"options",     "loglevel",     "",             new ValueContainerChar (debug),                         DT_CHARPTR, ValidateLogLevel},
-               {"options",     "netbuffersize","",             new ValueContainerInt  (&this->NetBufferSize),          DT_INTEGER, ValidateNetBufferSize},
-               {"options",     "maxwho",       "",             new ValueContainerInt  (&this->MaxWhoResults),          DT_INTEGER, ValidateMaxWho},
-               {"options",     "allowhalfop",  "",             new ValueContainerBool (&this->AllowHalfop),            DT_BOOLEAN, NoValidation},
-               {"dns",         "server",       "",             new ValueContainerChar (this->DNSServer),               DT_CHARPTR, ValidateDnsServer},
-               {"dns",         "timeout",      "",             new ValueContainerInt  (&this->dns_timeout),            DT_INTEGER, ValidateDnsTimeout},
-               {"options",     "moduledir",    "",             new ValueContainerChar (this->ModPath),                 DT_CHARPTR, ValidateModPath},
-               {"disabled",    "commands",     "",             new ValueContainerChar (this->DisabledCommands),        DT_CHARPTR, NoValidation},
-               {"options",     "userstats",    "",             new ValueContainerChar (this->UserStats),               DT_CHARPTR, NoValidation},
-               {"options",     "customversion","",             new ValueContainerChar (this->CustomVersion),           DT_CHARPTR, NoValidation},
-               {"options",     "hidesplits",   "",             new ValueContainerBool (&this->HideSplits),             DT_BOOLEAN, NoValidation},
-               {"options",     "hidebans",     "",             new ValueContainerBool (&this->HideBans),               DT_BOOLEAN, NoValidation},
-               {"options",     "hidewhois",    "",             new ValueContainerChar (this->HideWhoisServer),         DT_CHARPTR, NoValidation},
-               {"options",     "operspywhois", "",             new ValueContainerBool (&this->OperSpyWhois),           DT_BOOLEAN, NoValidation},
-               {"options",     "nouserdns",    "",             new ValueContainerBool (&this->NoUserDns),              DT_BOOLEAN, NoValidation},
-               {"options",     "syntaxhints",  "",             new ValueContainerBool (&this->SyntaxHints),            DT_BOOLEAN, NoValidation},
-               {"options",     "cyclehosts",   "",             new ValueContainerBool (&this->CycleHosts),             DT_BOOLEAN, NoValidation},
-               {"options",     "ircumsgprefix","0",            new ValueContainerBool (&this->UndernetMsgPrefix),      DT_BOOLEAN, NoValidation},
-               {"pid",         "file",         "",             new ValueContainerChar (this->PID),                     DT_CHARPTR, NoValidation},
-               {"whowas",      "groupsize",    "10",           new ValueContainerInt  (&this->WhoWasGroupSize),        DT_INTEGER, NoValidation},
-               {"whowas",      "maxgroups",    "10240",        new ValueContainerInt  (&this->WhoWasMaxGroups),        DT_INTEGER, NoValidation},
-               {"whowas",      "maxkeep",      "3600",         new ValueContainerChar (maxkeep),                       DT_CHARPTR, ValidateWhoWas},
-               {"die",         "value",        "",             new ValueContainerChar (this->DieValue),                DT_CHARPTR, NoValidation},
+               {"options",     "softlimit",    MAXCLIENTS_S,           new ValueContainerUInt (&this->SoftLimit),              DT_INTEGER, ValidateSoftLimit},
+               {"options",     "somaxconn",    SOMAXCONN_S,            new ValueContainerInt  (&this->MaxConn),                DT_INTEGER, ValidateMaxConn},
+               {"server",      "name",         "",                     new ValueContainerChar (this->ServerName),              DT_CHARPTR, ValidateServerName},
+               {"server",      "description",  "Configure Me",         new ValueContainerChar (this->ServerDesc),              DT_CHARPTR, NoValidation},
+               {"server",      "network",      "Network",              new ValueContainerChar (this->Network),                 DT_CHARPTR, NoValidation},
+               {"admin",       "name",         "",                     new ValueContainerChar (this->AdminName),               DT_CHARPTR, NoValidation},
+               {"admin",       "email",        "Mis@configu.red",      new ValueContainerChar (this->AdminEmail),              DT_CHARPTR, NoValidation},
+               {"admin",       "nick",         "Misconfigured",        new ValueContainerChar (this->AdminNick),               DT_CHARPTR, NoValidation},
+               {"files",       "motd",         "",                     new ValueContainerChar (this->motd),                    DT_CHARPTR, ValidateMotd},
+               {"files",       "rules",        "",                     new ValueContainerChar (this->rules),                   DT_CHARPTR, ValidateRules},
+               {"power",       "diepass",      "",                     new ValueContainerChar (this->diepass),                 DT_CHARPTR, NoValidation},      
+               {"power",       "pause",        "",                     new ValueContainerInt  (&this->DieDelay),               DT_INTEGER, NoValidation},
+               {"power",       "restartpass",  "",                     new ValueContainerChar (this->restartpass),             DT_CHARPTR, NoValidation},
+               {"options",     "prefixquit",   "",                     new ValueContainerChar (this->PrefixQuit),              DT_CHARPTR, NoValidation},
+               {"options",     "loglevel",     "default",              new ValueContainerChar (debug),                         DT_CHARPTR, ValidateLogLevel},
+               {"options",     "netbuffersize","10240",                new ValueContainerInt  (&this->NetBufferSize),          DT_INTEGER, ValidateNetBufferSize},
+               {"options",     "maxwho",       "128",                  new ValueContainerInt  (&this->MaxWhoResults),          DT_INTEGER, ValidateMaxWho},
+               {"options",     "allowhalfop",  "0",                    new ValueContainerBool (&this->AllowHalfop),            DT_BOOLEAN, NoValidation},
+               {"dns",         "server",       "",                     new ValueContainerChar (this->DNSServer),               DT_CHARPTR, ValidateDnsServer},
+               {"dns",         "timeout",      "5",                    new ValueContainerInt  (&this->dns_timeout),            DT_INTEGER, NoValidation},
+               {"options",     "moduledir",    MOD_PATH,               new ValueContainerChar (this->ModPath),                 DT_CHARPTR, NoValidation},
+               {"disabled",    "commands",     "",                     new ValueContainerChar (this->DisabledCommands),        DT_CHARPTR, NoValidation},
+               {"options",     "userstats",    "",                     new ValueContainerChar (this->UserStats),               DT_CHARPTR, NoValidation},
+               {"options",     "customversion","",                     new ValueContainerChar (this->CustomVersion),           DT_CHARPTR, NoValidation},
+               {"options",     "hidesplits",   "0",                    new ValueContainerBool (&this->HideSplits),             DT_BOOLEAN, NoValidation},
+               {"options",     "hidebans",     "0",                    new ValueContainerBool (&this->HideBans),               DT_BOOLEAN, NoValidation},
+               {"options",     "hidewhois",    "",                     new ValueContainerChar (this->HideWhoisServer),         DT_CHARPTR, NoValidation},
+               {"options",     "operspywhois", "0",                    new ValueContainerBool (&this->OperSpyWhois),           DT_BOOLEAN, NoValidation},
+               {"options",     "nouserdns",    "0",                    new ValueContainerBool (&this->NoUserDns),              DT_BOOLEAN, NoValidation},
+               {"options",     "syntaxhints",  "0",                    new ValueContainerBool (&this->SyntaxHints),            DT_BOOLEAN, NoValidation},
+               {"options",     "cyclehosts",   "0",                    new ValueContainerBool (&this->CycleHosts),             DT_BOOLEAN, NoValidation},
+               {"options",     "ircumsgprefix","0",                    new ValueContainerBool (&this->UndernetMsgPrefix),      DT_BOOLEAN, NoValidation},
+               {"pid",         "file",         "",                     new ValueContainerChar (this->PID),                     DT_CHARPTR, NoValidation},
+               {"whowas",      "groupsize",    "10",                   new ValueContainerInt  (&this->WhoWasGroupSize),        DT_INTEGER, NoValidation},
+               {"whowas",      "maxgroups",    "10240",                new ValueContainerInt  (&this->WhoWasMaxGroups),        DT_INTEGER, NoValidation},
+               {"whowas",      "maxkeep",      "3600",                 new ValueContainerChar (maxkeep),                       DT_CHARPTR, ValidateWhoWas},
+               {"die",         "value",        "",                     new ValueContainerChar (this->DieValue),                DT_CHARPTR, NoValidation},
                {NULL}
        };
 
@@ -643,62 +631,63 @@ void ServerConfig::Read(bool bail, userrec* user)
                {"connect",
                                {"allow",       "deny",         "password",     "timeout",      "pingfreq",     "flood",
                                "threshold",    "sendq",        "recvq",        "localmax",     "globalmax",    NULL},
-                               {"", "", "", "", "", "", "", "", "", "", "", NULL},
+                               {"",            "",             "",             "",             "",             "",
+                                "",            "",             "",             "",             "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR,     DT_CHARPTR,     DT_INTEGER,     DT_INTEGER,     DT_INTEGER,
                                 DT_INTEGER,    DT_INTEGER,     DT_INTEGER,     DT_INTEGER,     DT_INTEGER},
                                InitConnect, DoConnect, DoneConnect},
 
                {"uline",
                                {"server",      NULL},
-                               {"", NULL},
+                               {"",            NULL},
                                {DT_CHARPTR},
                                InitULine,DoULine,DoneULine},
 
                {"banlist",
                                {"chan",        "limit",        NULL},
-                               {"", "", NULL},
+                               {"",            "",             NULL},
                                {DT_CHARPTR,    DT_INTEGER},
                                InitMaxBans, DoMaxBans, DoneMaxBans},
 
                {"module",
                                {"name",        NULL},
-                               {"", NULL},
+                               {"",            NULL},
                                {DT_CHARPTR},
                                InitModule, DoModule, DoneModule},
 
                {"badip",
                                {"reason",      "ipmask",       NULL},
-                               {"", "", NULL},
+                               {"No reason",   "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
-                               InitXLine, DoZLine, DoneXLine},
+                               InitXLine, DoZLine, DoneZLine},
 
                {"badnick",
                                {"reason",      "nick",         NULL},
-                               {"", "", NULL},
+                               {"No reason",   "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
-                               InitXLine, DoQLine, DoneXLine},
+                               InitXLine, DoQLine, DoneQLine},
 
                {"badhost",
                                {"reason",      "host",         NULL},
-                               {"", "", NULL},
+                               {"No reason",   "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
-                               InitXLine, DoKLine, DoneXLine},
+                               InitXLine, DoKLine, DoneKLine},
 
                {"exception",
                                {"reason",      "host",         NULL},
-                               {"", "", NULL},
+                               {"No reason",   "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
-                               InitXLine, DoELine, DoneXLine},
+                               InitXLine, DoELine, DoneELine},
 
                {"type",
                                {"name",        "classes",      NULL},
-                               {"", "", NULL},
+                               {"",            "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
                                InitTypes, DoType, DoneClassesAndTypes},
 
                {"class",
                                {"name",        "commands",     NULL},
-                               {"", "", NULL},
+                               {"",            "",             NULL},
                                {DT_CHARPTR,    DT_CHARPTR},
                                InitClasses, DoClass, DoneClassesAndTypes},
 
@@ -974,10 +963,7 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
                {
                        case '\n':
                                if (in_quote)
-                               {
-                                       ServerInstance->Log(DEBUG, "Got \\n inside value");
                                        line += '\n';
-                               }
                                linenumber++;
                        case '\r':
                                if (!in_quote)
@@ -1002,11 +988,9 @@ bool ServerConfig::LoadConf(ConfigDataHash &target, const char* filename, std::o
                if ((ch == '\\') && (in_quote) && (in_tag))
                {
                        line += ch;
-                       ServerInstance->Log(DEBUG,"Escape sequence in config line.");
                        char real_character;
                        if (conf.get(real_character))
                        {
-                               ServerInstance->Log(DEBUG,"Escaping %c", real_character);
                                if (real_character == 'n')
                                        real_character = '\n';
                                line += real_character;
@@ -1314,22 +1298,20 @@ bool ServerConfig::ConfValue(ConfigDataHash &target, const std::string &tag, con
                                }
                        }
                }
+               if (!default_value.empty())
+               {
+                       result = default_value;
+                       return true;
+               }
        }
        else if(pos == 0)
        {
                if (!default_value.empty())
                {
                        result = default_value;
-                       ServerInstance->Log(DEBUG, "No <%s> tags in config file using default.", tag.c_str());
                        return true;
                }
-               ServerInstance->Log(DEBUG, "No <%s> tags in config file.", tag.c_str());
-       }
-       else
-       {
-               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;
 }
        
@@ -1356,6 +1338,42 @@ bool ServerConfig::ConfValueInteger(ConfigDataHash &target, const std::string &t
        stream.str(value);
        if(!(stream >> result))
                return false;
+       else
+       {
+               if (!value.empty())
+               {
+                       if (value.substr(0,2) == "0x")
+                       {
+                               char* endptr;
+
+                               value.erase(0,2);
+                               result = strtol(value.c_str(), &endptr, 16);
+
+                               /* No digits found */
+                               if (endptr == value.c_str())
+                                       return false;
+                       }
+                       else
+                       {
+                               char denominator = *(value.end() - 1);
+                               switch (toupper(denominator))
+                               {
+                                       case 'K':
+                                               /* Kilobytes -> bytes */
+                                               result = result * 1024;
+                                       break;
+                                       case 'M':
+                                               /* Megabytes -> bytes */
+                                               result = result * 1024 * 1024;
+                                       break;
+                                       case 'G':
+                                               /* Gigabytes -> bytes */
+                                               result = result * 1024 * 1024 * 1024;
+                                       break;
+                               }
+                       }
+               }
+       }
        return r;
 }
 
@@ -1412,14 +1430,6 @@ int ServerConfig::ConfVarEnum(ConfigDataHash &target, const std::string &tag, in
                
                return iter->second.size();
        }
-       else if(pos == 0)
-       {
-               ServerInstance->Log(DEBUG, "No <%s> tags in config file.", tag.c_str());
-       }
-       else
-       {
-               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;
 }
@@ -1428,6 +1438,9 @@ int ServerConfig::ConfVarEnum(ConfigDataHash &target, const std::string &tag, in
  */
 bool ServerConfig::ReadFile(file_cache &F, const char* fname)
 {
+       if (!fname || !*fname)
+               return false;
+
        FILE* file = NULL;
        char linebuf[MAXBUF];