configreader.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007, 2009 Dennis Friis <[email protected]>
 *   Copyright (C) 2006-2008 Craig Edwards <[email protected]>
 *   Copyright (C) 2006-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2006 Oliver Lupton <[email protected]>
 *
 * 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/>.
 */
 
 
#ifndef INSPIRCD_CONFIGREADER
#define INSPIRCD_CONFIGREADER
 
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include "inspircd.h"
#include "modules.h"
#include "socketengine.h"
#include "socket.h"
 
class CoreExport ConfigTag : public refcountbase
{
        std::vector<KeyVal> items;
 public:
        const std::string tag;
        const std::string src_name;
        const int src_line;
 
        std::string getString(const std::string& key, const std::string& def = "");
        long getInt(const std::string& key, long def = 0);
        double getFloat(const std::string& key, double def = 0);
        bool getBool(const std::string& key, bool def = false);
 
        bool readString(const std::string& key, std::string& value, bool allow_newline = false);
 
        std::string getTagLocation();
 
        inline const std::vector<KeyVal>& getItems() const { return items; }
 
        static ConfigTag* create(const std::string& Tag, const std::string& file, int line, std::vector<KeyVal>*& Items);
 private:
        ConfigTag(const std::string& Tag, const std::string& file, int line);
};
 
class ServerLimits
{
 public:
        size_t NickMax;
        size_t ChanMax;
        size_t MaxModes;
        size_t IdentMax;
        size_t MaxQuit;
        size_t MaxTopic;
        size_t MaxKick;
        size_t MaxGecos;
        size_t MaxAway;
 
        ServerLimits() : NickMax(31), ChanMax(64), MaxModes(20), IdentMax(12), MaxQuit(255), MaxTopic(307), MaxKick(255), MaxGecos(128), MaxAway(200)
        {
        }
};
 
struct CommandLineConf
{
        bool nofork;
 
        bool forcedebug;
 
        bool writelog;
 
        bool TestSuite;
 
        int argc;
 
        char** argv;
 
        std::string startup_log;
};
 
class CoreExport OperInfo : public refcountbase
{
 public:
        std::set<std::string> AllowedOperCommands;
        std::set<std::string> AllowedPrivs;
 
        std::bitset<64> AllowedUserModes;
 
        std::bitset<64> AllowedChanModes;
 
        reference<ConfigTag> oper_block;
        reference<ConfigTag> type_block;
        std::vector<reference<ConfigTag> > class_blocks;
        std::string name;
 
        std::string getConfig(const std::string& key);
        void init();
 
        inline const char* NameStr()
        {
                return irc::Spacify(name.c_str());
        }
};
 
class CoreExport ServerConfig
{
  private:
        void CrossCheckOperClassType();
        void CrossCheckConnectBlocks(ServerConfig* current);
 
 public:
 
        ConfigTag* ConfValue(const std::string& tag);
 
        ConfigTagList ConfTags(const std::string& tag);
 
        ConfigTag* EmptyTag;
 
        std::stringstream errstr;
 
        bool valid;
 
        bool WildcardIPv6;
 
        enum InviteAnnounceState { INVITE_ANNOUNCE_NONE, INVITE_ANNOUNCE_ALL, INVITE_ANNOUNCE_OPS, INVITE_ANNOUNCE_DYNAMIC };
        enum OperSpyWhoisState { SPYWHOIS_NONE, SPYWHOIS_SINGLEMSG, SPYWHOIS_SPLITMSG };
 
        ConfigDataHash config_data;
 
        ConfigFileCache Files;
 
        ServerLimits Limits;
 
        CommandLineConf cmdline;
 
        int c_ipv4_range;
 
        int c_ipv6_range;
 
        int WhoWasGroupSize;
 
        int WhoWasMaxGroups;
 
        int WhoWasMaxKeep;
 
        std::string ServerName;
 
        std::string MoronBanner;
 
        /* Holds the network name the local server
         * belongs to. This is an arbitary field defined
         * by the administrator.
         */
        std::string Network;
 
        std::string ServerDesc;
 
        std::string AdminName;
 
        std::string AdminEmail;
 
        std::string AdminNick;
 
        std::string diepass;
 
        std::string restartpass;
 
        std::string powerhash;
 
        std::string motd;
 
        std::string rules;
 
        std::string PrefixQuit;
 
        std::string SuffixQuit;
 
        std::string FixedQuit;
 
        std::string PrefixPart;
 
        std::string SuffixPart;
 
        std::string FixedPart;
 
        std::string DNSServer;
 
        bool DisabledDontExist;
 
        std::string DisabledCommands;
 
        char DisabledUModes[64];
 
        char DisabledCModes[64];
 
        std::string ModPath;
 
        bool GenericOper;
 
        bool RestrictBannedUsers;
 
        bool HideModeLists[256];
 
        int dns_timeout;
 
        int NetBufferSize;
 
        int MaxConn;
 
        unsigned int SoftLimit;
 
        unsigned int MaxTargets;
 
        bool HideSplits;
 
        bool HideBans;
 
        InviteAnnounceState AnnounceInvites;
 
        OperSpyWhoisState OperSpyWhois;
 
        bool RawLog;
 
        std::string HideWhoisServer;
 
        std::string HideKillsServer;
 
        bool HideULineKills;
 
        std::string PID;
 
        ClassVector Classes;
 
        std::string data005;
 
        std::vector<std::string> isupport;
 
        std::string UserStats;
 
        std::string DefaultModes;
 
        std::string CustomVersion;
 
        std::map<irc::string, bool> ulines;
 
        std::map<std::string, int> maxbans;
 
        bool NoUserDns;
 
        bool SyntaxHints;
 
        bool CycleHosts;
 
        bool CycleHostsFromUser;
 
        bool UndernetMsgPrefix;
 
        bool FullHostInTopic;
 
        OperIndex oper_blocks;
 
        unsigned int MaxChans;
 
        unsigned int OperMaxChans;
 
        std::string sid;
 
        ServerConfig();
 
        ~ServerConfig();
 
        const std::string& GetSID();
 
        void Update005();
 
        void Send005(User* user);
 
        void Read();
 
        void Apply(ServerConfig* old, const std::string &useruid);
        void ApplyModules(User* user);
 
        void Fill();
 
        bool StartsWithWindowsDriveLetter(const std::string &path);
 
        bool ApplyDisabledCommands(const std::string& data);
 
        static const char* CleanFilename(const char* name);
 
        static bool FileExists(const char* file);
 
        bool InvBypassModes;
 
        bool NoSnoticeStack;
 
        bool WelcomeNotice;
};
 
class CoreExport ConfigReaderThread : public Thread
{
        ServerConfig* Config;
        volatile bool done;
 public:
        const std::string TheUserUID;
        ConfigReaderThread(const std::string &useruid)
                : Config(new ServerConfig), done(false), TheUserUID(useruid)
        {
        }
 
        virtual ~ConfigReaderThread()
        {
                delete Config;
        }
 
        void Run();
        void Finish();
        bool IsDone() { return done; }
};
 
#endif