Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

home » brain » inspircd-cvs » inspircd » include

configreader.h

Go to the documentation of this file.

/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
 * See: http://www.inspircd.org/wiki/index.php/Credits
 *
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */

#ifndef INSPIRCD_CONFIGREADER
#define INSPIRCD_CONFIGREADER

/* handy defines */

#define CHANOPS_EXEMPT(s, m) (s->Config->ExemptChanOps[(unsigned char)m])

#include <sstream>
#include <string>
#include <vector>
#include <map>
#include "inspircd.h"
#include "modules.h"
#include "socketengine.h"
#include "socket.h"

/* Required forward definitions */
class ServerConfig;
class InspIRCd;
class BufferedSocket;

enum ConfigDataType
{
        DT_NOTHING       = 0,           /* No data */
        DT_INTEGER       = 1,           /* Integer */
        DT_CHARPTR       = 2,           /* Char pointer */
        DT_BOOLEAN       = 3,           /* Boolean */
        DT_HOSTNAME      = 4,           /* Hostname syntax */
        DT_NOSPACES      = 5,           /* No spaces */
        DT_IPADDRESS     = 6,           /* IP address (v4, v6) */
        DT_CHANNEL       = 7,           /* Channel name */
        DT_ALLOW_WILD    = 64,          /* Allow wildcards/CIDR in DT_IPADDRESS */
        DT_ALLOW_NEWLINE = 128,         /* New line characters allowed in DT_CHARPTR */
        DT_BOOTONLY      = 256          /* Can only be set on startup, not on rehash */
};

#define MAX_VALUES_PER_TAG 18

class ValueItem
{
        std::string v;
 public:
        ValueItem(int value);
        ValueItem(bool value);
        ValueItem(const char* value);
        void Set(const char* val);
        void Set(int value);
        int GetInteger();
        char* GetString();
        bool GetBool();
};

class ValueContainerBase
{
 public:
        ValueContainerBase() { }
        virtual ~ValueContainerBase() { }
};

template<typename T> class ValueContainer : public ValueContainerBase
{
        T val;
 public:

        ValueContainer()
        {
                val = NULL;
        }

        ValueContainer(T Val)
        {
                val = Val;
        }

        void Set(T newval, size_t s)
        {
                memcpy(val, newval, s);
        }
};

typedef ValueContainer<bool*> ValueContainerBool;

typedef ValueContainer<unsigned int*> ValueContainerUInt;

typedef ValueContainer<char*> ValueContainerChar;

typedef ValueContainer<int*> ValueContainerInt;

typedef ValueContainer<size_t*> ValueContainerST;

typedef std::deque<ValueItem> ValueList;

typedef bool (*Validator)(ServerConfig* conf, const char*, const char*, ValueItem&);
typedef bool (*MultiValidator)(ServerConfig* conf, const char*, char**, ValueList&, int*);
typedef bool (*MultiNotify)(ServerConfig* conf, const char*);

struct InitialConfig
{
        const char* tag;
        const char* value;
        const char* default_value;
        ValueContainerBase* val;
        int datatype;
        Validator validation_function;
};

struct Deprecated
{
        const char* tag;
        const char* value;
        const char* reason;
};

struct MultiConfig
{
        const char*     tag;
        const char*     items[MAX_VALUES_PER_TAG];
        const char* items_default[MAX_VALUES_PER_TAG];
        int             datatype[MAX_VALUES_PER_TAG];
        MultiNotify     init_function;
        MultiValidator  validation_function;
        MultiNotify     finish_function;
};

typedef std::map<irc::string,char*> opertype_t;

struct operclass_data : public Extensible
{
        char* commandlist;
        char* cmodelist;
        char* umodelist;
};

typedef std::map<irc::string, operclass_data> operclass_t;


class ServerLimits : public Extensible
{
 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;

        /* Creating the class initialises it to the defaults
         * as in 1.1's ./configure script. Reading other values
         * from the config will change these values.
         */
        ServerLimits() : NickMax(31), ChanMax(64), MaxModes(20), IdentMax(12), MaxQuit(255), MaxTopic(307), MaxKick(255), MaxGecos(128), MaxAway(200)
        {
        }

        void Finalise()
        {
                NickMax++;
                ChanMax++;
                IdentMax++;
                MaxQuit++;
                MaxTopic++;
                MaxKick++;
                MaxGecos++;
                MaxAway++;
        }
};

class CoreExport ServerConfig : public Extensible
{
  private:
        InspIRCd* ServerInstance;

        std::vector<std::string> include_stack;

        bool ParseLine(ConfigDataHash &target, const std::string &filename, std::string &line, long &linenumber, std::ostringstream &errorstream);

        bool CheckOnce(const char* tag, ConfigDataHash &newconf);

 public:
        bool DoPipe(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream);

        bool DoInclude(ConfigDataHash &target, const std::string &file, std::ostringstream &errorstream);

        User* RehashUser;

        std::string RehashParameter;

        std::ostringstream errstr;

        ConfigDataHash newconfig;

        std::map<std::string, std::istream*> IncludedFiles;

        enum InviteAnnounceState { INVITE_ANNOUNCE_NONE, INVITE_ANNOUNCE_ALL, INVITE_ANNOUNCE_OPS, INVITE_ANNOUNCE_DYNAMIC };

        Validator DNSServerValidator;

        InspIRCd* GetInstance();

        int DoDownloads();
          
        ConfigDataHash config_data;

        ServerLimits Limits;

        int c_ipv4_range;

        int c_ipv6_range;

        int WhoWasGroupSize;

        int WhoWasMaxGroups;

        int WhoWasMaxKeep;

        char ServerName[MAXBUF];

        char MoronBanner[MAXBUF];
        
        /* Holds the network name the local server
         * belongs to. This is an arbitary field defined
         * by the administrator.
         */
        char Network[MAXBUF];

        char ServerDesc[MAXBUF];

        char AdminName[MAXBUF];

        char AdminEmail[MAXBUF];

        char AdminNick[MAXBUF];

        char diepass[MAXBUF];

        char restartpass[MAXBUF];

        char powerhash[MAXBUF];

        char motd[MAXBUF];

        char rules[MAXBUF];

        char PrefixQuit[MAXBUF];

        char SuffixQuit[MAXBUF];

        char FixedQuit[MAXBUF];

        char PrefixPart[MAXBUF];

        char SuffixPart[MAXBUF];

        char FixedPart[MAXBUF];

        char DieValue[MAXBUF];

        char DNSServer[MAXBUF];

        bool DisabledDontExist;

        char DisabledCommands[MAXBUF];

        char DisabledUModes[64];

        char DisabledCModes[64];

        char ModPath[1024];

        char MyExecutable[1024];

        FILE *log_file;

        bool nofork;
        
        bool forcedebug;
        
        bool writelog;

        bool AllowHalfop;

        bool HideModeLists[256];

        bool ExemptChanOps[256];

        int dns_timeout;

        int NetBufferSize;

        int MaxConn;

        unsigned int SoftLimit;

        unsigned int MaxTargets;

        int MaxWhoResults;

        int debugging;

        int DieDelay;

        bool HideSplits;

        bool HideBans;

        InviteAnnounceState AnnounceInvites;

        bool OperSpyWhois;

        char HideWhoisServer[MAXBUF];

        char HideKillsServer[MAXBUF];

        file_cache MOTD;

        file_cache RULES;

        char PID[1024];

        ClassVector Classes;

        std::vector<ListenSocket*> ports;

        std::map<BufferedSocket*, Module*> SocketIOHookModule;

        std::string data005;

        std::vector<std::string> isupport;

        char UserStats[MAXBUF];
        
        std::string logpath;

        char DefaultModes[MAXBUF];

        char CustomVersion[MAXBUF];

        std::map<irc::string, bool> ulines;

        std::map<std::string, int> maxbans;

        std::string MyDir;

        bool NoUserDns;

        bool SyntaxHints;

        bool CycleHosts;

        bool UndernetMsgPrefix;

        bool FullHostInTopic;

        opertype_t opertypes;

        operclass_t operclass;

        char** argv;

        int argc;

        unsigned int MaxChans;

        unsigned int OperMaxChans;

        char sid[MAXBUF];

        bool TestSuite;

        ServerConfig(InspIRCd* Instance);

        void ClearStack();

        std::string GetSID();

        void Update005();

        void Send005(User* user);

        void Read(bool bail, User* user);

        bool ReadFile(file_cache &F, const char* fname);

        /* Returns true if the given string starts with a windows drive letter
         */
        bool StartsWithWindowsDriveLetter(const std::string &path);

        void ReportConfigError(const std::string &errormessage, bool bail, User* user);

        bool LoadConf(ConfigDataHash &target, FILE* &conf, const char* filename, std::ostringstream &errorstream);

        bool LoadConf(ConfigDataHash &target, FILE* &conf, const std::string &filename, std::ostringstream &errorstream);
        
        /* Both these return true if the value existed or false otherwise */
        
        bool ConfValue(ConfigDataHash &target, const char* tag, const char* var, int index, char* result, int length, bool allow_linefeeds = false);
        bool ConfValue(ConfigDataHash &target, const char* tag, const char* var, const char* default_value, int index, char* result, int length, bool allow_linefeeds = false);

        bool ConfValue(ConfigDataHash &target, const std::string &tag, const std::string &var, int index, std::string &result, bool allow_linefeeds = false);
        bool ConfValue(ConfigDataHash &target, const std::string &tag, const std::string &var, const std::string &default_value, int index, std::string &result, bool allow_linefeeds = false);
        
        bool ConfValueInteger(ConfigDataHash &target, const char* tag, const char* var, int index, int &result);
        bool ConfValueInteger(ConfigDataHash &target, const char* tag, const char* var, const char* default_value, int index, int &result);
        bool ConfValueInteger(ConfigDataHash &target, const std::string &tag, const std::string &var, int index, int &result);
        bool ConfValueInteger(ConfigDataHash &target, const std::string &tag, const std::string &var, const std::string &default_value, int index, int &result);
        
        bool ConfValueBool(ConfigDataHash &target, const char* tag, const char* var, int index);
        bool ConfValueBool(ConfigDataHash &target, const char* tag, const char* var, const char* default_value, int index);
        bool ConfValueBool(ConfigDataHash &target, const std::string &tag, const std::string &var, int index);
        bool ConfValueBool(ConfigDataHash &target, const std::string &tag, const std::string &var, const std::string &default_value, int index);
        
        int ConfValueEnum(ConfigDataHash &target, const char* tag);
        int ConfValueEnum(ConfigDataHash &target, const std::string &tag);
        
        int ConfVarEnum(ConfigDataHash &target, const char* tag, int index);
        int ConfVarEnum(ConfigDataHash &target, const std::string &tag, int index);

        void ValidateHostname(const char* p, const std::string &tag, const std::string &val);

        void ValidateIP(const char* p, const std::string &tag, const std::string &val, bool wild);

        void ValidateNoSpaces(const char* p, const std::string &tag, const std::string &val);

        Module* GetIOHook(BufferedSocket* is);

        bool AddIOHook(Module* iomod, BufferedSocket* is);

        bool DelIOHook(BufferedSocket* is);

        std::string GetFullProgDir();

        static bool DirValid(const char* dirandfile);

        static char* CleanFilename(char* name);

        static bool FileExists(const char* file);

        bool InvBypassModes;

};

CoreExport bool InitializeDisabledCommands(const char* data, InspIRCd* ServerInstance);

bool InitTypes(ServerConfig* conf, const char* tag);

bool InitClasses(ServerConfig* conf, const char* tag);

bool DoType(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);

bool DoClass(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);

bool DoneClassesAndTypes(ServerConfig* conf, const char* tag);



bool InitXLine(ServerConfig* conf, const char* tag);
 
bool DoZLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);

bool DoQLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);

bool DoKLine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);

bool DoELine(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types);




#endif