config.h

Go to the documentation of this file.

/*
 *
 * (C) 2003-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church.
 *
 */

#ifndef CONFIG_H
#define CONFIG_H

#include "account.h"
#include "regchannel.h"
#include "users.h"

typedef std::pair<Anope::string, Anope::string> KeyVal;

typedef std::vector<KeyVal> KeyValList;

typedef std::multimap<Anope::string, KeyValList> ConfigDataHash;

// Required forward definitions

enum ConfigDataType
{
        DT_NOTHING, // No data
        DT_INTEGER, // Integer
        DT_UINTEGER, // Unsigned Integer
        DT_LUINTEGER, // Long Unsigned Integer
        DT_STRING, // Anope::string
        DT_BOOLEAN, // Boolean
        DT_HOSTNAME, // Hostname syntax
        DT_NOSPACES, // No spaces
        DT_IPADDRESS, // IP address (v4, v6)
        DT_TIME, // Time value
        DT_NORELOAD = 32, // Item can't be reloaded after startup
        DT_ALLOW_WILD = 64, // Allow wildcards/CIDR in DT_IPADDRESS
        DT_ALLOW_NEWLINE = 128, // New line characters allowed in DT_STRING
        DT_ALLOW_EMPTY = 256 // Allow empty value
};

class CoreExport ValueItem
{
 private:
        Anope::string v;
 public:
        ValueItem();
        ValueItem(int);
        ValueItem(bool);
        ValueItem(const Anope::string &);
        ValueItem(long);
        void Set(const Anope::string &);
        void Set(int);
        int GetInteger() const;
        const char *GetString() const;
        inline const Anope::string &GetValue() const { return v; }
        bool GetBool() const;
};

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

template<typename T> class ValueContainer : public ValueContainerBase
{
 private:
        T val;
 public:
        ValueContainer() : ValueContainerBase(), val(NULL) { }
        ValueContainer(T Val) : ValueContainerBase(), val(Val) { }
        ValueContainer(const ValueContainer &Val) : ValueContainerBase(), val(Val.val) { }
        ValueContainer &operator=(const ValueContainer &Val)
        {
                val = Val.val;
                return *this;
        }
        void Set(const T newval, size_t s)
        {
                memcpy(val, newval, s);
        }
};

template<> class ValueContainer<Anope::string *> : public ValueContainerBase
{
 private:
        Anope::string *val;
 public:
        ValueContainer() : ValueContainerBase(), val(NULL) { }
        ValueContainer(Anope::string *Val) : ValueContainerBase(), val(Val) { }
        ValueContainer(const ValueContainer &Val) : ValueContainerBase(), val(Val.val) { }
        ValueContainer &operator=(const ValueContainer &Val)
        {
                val = Val.val;
                return *this;
        }

        void Set(const Anope::string &newval)
        {
                *val = newval;
        }
        void Set(const char *newval)
        {
                *val = newval;
        }
};

typedef ValueContainer<bool *> ValueContainerBool;

typedef ValueContainer<unsigned *> ValueContainerUInt;

typedef ValueContainer<long unsigned *> ValueContainerLUInt;

typedef ValueContainer<int *> ValueContainerInt;

typedef ValueContainer<time_t *> ValueContainerTime;

typedef ValueContainer<Anope::string *> ValueContainerString;

typedef std::deque<ValueItem> ValueList;

typedef bool (*Validator)(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &);
typedef bool (*MultiValidator)(ServerConfig *, const Anope::string &, const Anope::string *, ValueList &, int *);
typedef bool (*MultiNotify)(ServerConfig *, const Anope::string &);

class ConfigurationFile
{
        Anope::string name;
        bool executable;
        FILE *fp;
 public:
        ConfigurationFile(const Anope::string &, bool);
        ~ConfigurationFile();
        const Anope::string &GetName() const;

        bool IsOpen() const;
        bool Open();
        void Close();
        bool End() const;
        Anope::string Read();
};

class CoreExport ConfigItems
{
 public:
        struct Item
        {
                Anope::string tag;
                Anope::string value;
                Anope::string default_value;
                ValueContainerBase *val;
                int datatype;
                Validator validation_function;
        } *Values;

        struct MultiItem
        {
                Anope::string tag;
                Anope::string items[17];
                Anope::string items_default[17];
                int datatype[17];
                MultiNotify init_function;
                MultiValidator validation_function;
                MultiNotify finish_function;
        } *MultiValues;

        ConfigItems(ServerConfig *conf);
        ~ConfigItems();
};

class CoreExport ServerConfig
{
 private:
        bool CheckOnce(const Anope::string &);
 public:
        ConfigDataHash config_data;
        ServerConfig();

        void Read();
        void LoadConf(ConfigurationFile &file);
        // Both these return true if the value existed or false otherwise
        bool ConfValue(ConfigDataHash &, const Anope::string &, const Anope::string &, int, Anope::string &, bool = false);
        bool ConfValue(ConfigDataHash &, const Anope::string &, const Anope::string &, const Anope::string &, int, Anope::string &, bool = false);
        bool ConfValueInteger(ConfigDataHash &, const Anope::string &, const Anope::string &, int, int &);
        bool ConfValueInteger(ConfigDataHash &, const Anope::string &, const Anope::string &, const Anope::string &, int, int &);
        bool ConfValueBool(ConfigDataHash &, const Anope::string &, const Anope::string &, int);
        bool ConfValueBool(ConfigDataHash &, const Anope::string &, const Anope::string &, const Anope::string &, int);
        int ConfValueEnum(const ConfigDataHash &, const Anope::string &);
        int ConfVarEnum(ConfigDataHash &, const Anope::string &, int);
        void ValidateHostname(const Anope::string &, const Anope::string &, const Anope::string &) const;
        void ValidateIP(const Anope::string &p, const Anope::string &, const Anope::string &, bool) const;
        void ValidateNoSpaces(const Anope::string &, const Anope::string &, const Anope::string &) const;

        struct Uplink
        {
                Anope::string host;
                unsigned port;
                Anope::string password;
                bool ipv6;

                Uplink(const Anope::string &_host, int _port, const Anope::string &_password, bool _ipv6) : host(_host), port(_port), password(_password), ipv6(_ipv6) { }
                bool operator==(const Uplink &other) const
                {
                        if (this->host != other.host)
                                return false;
                        if (this->port != other.port)
                                return false;
                        if (this->password != other.password)
                                return false;
                        if (this->ipv6 != other.ipv6)
                                return false;
                        return true;
                }
                inline bool operator!=(const Uplink &other) const { return !(*this == other); }
        };

        /* Host to bind to */
        Anope::string LocalHost;
        /* List of uplink servers to try and connect to */
        std::vector<Uplink *> Uplinks;

        /* Our server name */
        Anope::string ServerName;
        /* Our servers description */
        Anope::string ServerDesc;

        /* Name of the network were on */
        Anope::string NetworkName;
        /* The max legnth of nicks */
        unsigned NickLen;
        /* Max length of idents */
        unsigned UserLen;
        /* Max lenght of hostnames */
        unsigned HostLen;
        /* Max length of channel names */
        unsigned ChanLen;

        /* User and group to run as */
        Anope::string User;
        Anope::string Group;

        /* Casemapping to use */
        Anope::string CaseMap;

        /* Max length of passwords */
        unsigned PassLen;

        /* Filename for the PID file */
        Anope::string PIDFilename;
        /* MOTD filename */
        Anope::string MOTDFilename;

        Anope::string BotServ;
        Anope::string ChanServ;
        Anope::string Global;
        Anope::string HostServ;
        Anope::string NickServ;
        Anope::string OperServ;
        Anope::string MemoServ;

        /* True if its ok to not be able to save backs */
        bool NoBackupOkay;
        /* Do password checking when new people register */
        bool StrictPasswords;
        /* How many times you're allowed to give a bad password before being killed */
        unsigned BadPassLimit;
        /* How long before bad passwords are forgotten */
        time_t BadPassTimeout;
        /* Delay between automatic database updates */
        time_t UpdateTimeout;
        /* Delay between checks for expired nicks and channels */
        time_t ExpireTimeout;
        /* How long to wait for something from the uplink, this is passed to select() */
        time_t ReadTimeout;
        /* How often to send program errors */
        time_t WarningTimeout;
        /* How long to process things such as timers to see if there is anything to calll */
        time_t TimeoutCheck;
        /* Number of days backups are kept */
        int KeepBackups;
        /* Forbidding requires a reason */
        bool ForceForbidReason;
        /* Services should use privmsgs instead of notices */
        bool UsePrivmsg;
        /* Services only respond to full PRIVMSG client@services.server.name messages */
        bool UseStrictPrivMsg;
        /* This is not a configurable option.
         * Config::Config will set it depending on the value of UseStrictPrivMsg */
        Anope::string UseStrictPrivMsgString;
        /* Number of seconds between consecutive uses of the REGISTER command
         * Not to be confused with NSRegDelay */
        unsigned NickRegDelay;
        /* Max number if news items allowed in the list */
        unsigned NewsCount;
        /* Default mlock modes */
        Anope::string MLock;
        /* Unmlockable modes */
        Anope::string NoMLock;
        /* Modes that are required to be on registered channels */
        Anope::string CSRequire;
        /* Use server side mlock */
        bool UseServerSideMLock;
        /* Use server side topic lock */
        bool UseServerSideTopicLock;
        /* The max length for reasons (cs_kick, cs_ban, etc) */
        unsigned CSReasonMax;
        /* Default botmodes on channels, defaults to ao */
        Anope::string BotModes;
        /* How long to wait between connection attempts */
        int RetryWait;
        /* If services should hide unprivileged commands */
        bool HidePrivilegedCommands;
        /* If set, nicks cant be owned/everything is entirely account based */
        bool NoNicknameOwnership;
        /* Regex engine to use */
        Anope::string RegexEngine;

        /* A vector of our logfile options */
        std::vector<LogInfo *> LogInfos;

        /* Services can use email */
        bool UseMail;
        /* Path to the sendmail executable */
        Anope::string SendMailPath;
        /* Address to send from */
        Anope::string SendFrom;
        /* Only opers can have services send mail */
        bool RestrictMail;
        /* Delay between sending mail */
        time_t MailDelay;
        /* Don't quote the To: address */
        bool DontQuoteAddresses;
        /* Mail messages to send */
        Anope::string MailRegistrationSubject, MailRegistrationMessage;
        Anope::string MailResetSubject, MailResetMessage;
        Anope::string MailEmailchangeSubject, MailEmailchangeMessage;
        Anope::string MailMemoSubject, MailMemoMessage;

        /* Prefix of guest nicks when a user gets forced off of a nick */
        Anope::string NSGuestNickPrefix;
        /* Allow users to set kill immed on */
        bool NSAllowKillImmed;
        /* Don't allow nicks to use /ns group to regroup nicks */
        bool NSNoGroupChange;
        /* Default flags for newly registered nicks */
        std::set<Anope::string> NSDefFlags;
        /* All languages Anope is aware about */
        Anope::string Languages;
        /* Default language used by services */
        Anope::string NSDefLanguage;
        /* Users must be connected this long before they can register
         * Not to be confused with NickRegDelay */
        time_t NSRegDelay;
        /* Time before the registering mail will be resent */
        time_t NSResendDelay;
        /* How long before nicks expire */
        time_t NSExpire;
        /* How long before suspended nicks expire */
        time_t NSSuspendExpire;
        /* Time before unconfirmed nicks expire */
        time_t NSUnconfirmedExpire;
        /* Force email when registering */
        bool NSForceEmail;
        /* Force users to validate new email addresses */
        bool NSConfirmEmailChanges;
        /* Max number of nicks in a group */
        unsigned NSMaxAliases;
        /* Max number of allowed strings on the access list */
        unsigned NSAccessMax;
        /* Enforcer client user name */
        Anope::string NSEnforcerUser;
        /* Enforcer client hostname */
        Anope::string NSEnforcerHost;
        /* How long before recovered nicks are released */
        time_t NSReleaseTimeout;
        /* Max number of entries that can be returned from the list command */
        unsigned NSListMax;
        /* Only allow usermode +a etc on real services admins */
        bool NSSecureAdmins;
        /* Services opers must be /operd on the ircd aswell */
        bool NSStrictPrivileges;
        /* Type of confirmation to use, or to disable registration completely */
        Anope::string NSRegistration;
        /* A message sent to unregistered users on connect */
        Anope::string NSUnregisteredNotice;
        /* Core NickServ modules */
        Anope::string NickCoreModules;
        /* Set the proper channel modes on users when they identify */
        bool NSModeOnID;
        /* Add the users hostnask their access list when they register */
        bool NSAddAccessOnReg;
        /* Maximum number of channels on AJoin */
        unsigned AJoinMax;
        /* Kill & killquick delays before force changing off users */
        time_t NSKillQuick;
        time_t NSKill;
        /* Modes set on a user when they identify */
        Anope::string NSModesOnID;
        /* Restore nick/channels on recover */
        bool NSRestoreOnRecover;
        /* Whether or not to use SASL */
        bool NSSASL;
        /* If set, hides netsplits in the last_quit field of nicks */
        bool NSHideNetSplitQuit;

        /* Core ChanServ modules */
        Anope::string ChanCoreModules;
        /* Default flags for newly registered channels */
        std::set<Anope::string> CSDefFlags;
        /* Max number of channels a user can own */
        unsigned CSMaxReg;
        /* Time before a channel expires */
        time_t CSExpire;
        /* How long before suspended channels expire */
        time_t CSSuspendExpire;
        /* How long before forbidden channels expire */
        time_t CSForbidExpire;
        /* Default ban type to use for channels */
        int CSDefBantype;
        /* Max number of entries allowed on channel access lists */
        unsigned CSAccessMax;
        /* Max number of entries allowed on autokick lists */
        unsigned CSAutokickMax;
        /* Default autokick reason */
        Anope::string CSAutokickReason;
        /* Time ChanServ should stay in the channel to hold it to keep users from getting in */
        time_t CSInhabit;
        /* Max number of entries allowed to be returned from the LIST command */
        unsigned CSListMax;
        /* true to make ChanServ oper only */
        bool CSOpersOnly;

        /* Max number of memos allowed */
        unsigned MSMaxMemos;
        /* Time you must wait between sending memos */
        time_t MSSendDelay;
        /* Notify all of the aliases of the core the memo was sent to */
        bool MSNotifyAll;
        /* Who can use memos reciepts */
        unsigned MSMemoReceipt;

        /* Valid chars allowed in vhosts */
        Anope::string VhostChars;
        /* Allow undotted vhosts? */
        bool VhostUndotted;
        /* Chars disallowed at the beginning or end of vhosts */
        Anope::string VhostDisallowBE;

        /* Core BotServ modules */
        Anope::string BotCoreModules;
        /* Default BotServ flags */
        std::set<Anope::string> BSDefFlags;
        /* How long before botserv forgets a user. This is used for flood kickers etc */
        time_t BSKeepData;
        /* Min number of users to have in the channel before the service bot joins */
        unsigned BSMinUsers;
        /* Max number of words allowed on the badwordslist */
        unsigned BSBadWordsMax;
        /* BotServ bot only joins if it would normally allowed to, abides by bans etc */
        bool BSSmartJoin;
        /* Dont tell users what badword they used */
        bool BSGentleBWReason;
        /* Case sensitive badwords matching */
        bool BSCaseSensitive;
        /* Char to use for the fantasy char, eg ! */
        Anope::string BSFantasyCharacter;

        /* Only show /stats o to opers */
        bool HideStatsO;
        /* Send out a global when services shut down or restart */
        bool GlobalOnCycle;
        /* Don't include the opers name in globals */
        bool AnonymousGlobal;
        /* Dont allow users to register nicks with oper names in them */
        bool RestrictOperNicks;
        /* Message to send when shutting down */
        Anope::string GlobalOnCycleMessage;
        /* Message to send when starting up */
        Anope::string GlobalOnCycleUP;
        /* Super admin is allowed */
        bool SuperAdmin;
        /* Default expiry time for akills */
        time_t AutokillExpiry;
        /* Default expiry time for chan kills */
        time_t ChankillExpiry;
        /* Default expiry time for SNLine Expire */
        time_t SNLineExpiry;
        /* Default expiry time for SQLines */
        time_t SQLineExpiry;
        /* Actually akill the user when the akill is added */
        bool AkillOnAdd;
        /* Kill users on SNLine */
        bool KillonSNline;
        /* Kill users on SQline */
        bool KillonSQline;
        /* Add the akillers nick to the akill reason */
        bool AddAkiller;
        /* Add akill ids to akill reason */
        bool AkillIds;

        /* Limit sessions */
        bool LimitSessions;
        /* The default session limit */
        unsigned DefSessionLimit;
        /* How long before exceptions expire */
        time_t ExceptionExpiry;
        /* How many times to kill before adding an KILL */
        unsigned MaxSessionKill;
        /* Max limit that can be used for exceptions */
        unsigned MaxSessionLimit;
        /* How long session akills should last */
        time_t SessionAutoKillExpiry;
        /* Number of bits to use when comparing session IPs */
        unsigned SessionIPv4CIDR;
        unsigned SessionIPv6CIDR;
        /* Reason to use for session kills */
        Anope::string SessionLimitExceeded;
        /* Optional second reason */
        Anope::string SessionLimitDetailsLoc;
        /* OperServ requires you to be an operator */
        bool OSOpersOnly;

        /* List of modules to autoload */
        std::list<Anope::string> ModulesAutoLoad;

        /* Seed to use for RNG */
        unsigned long Seed;

        /* Numeric */
        Anope::string Numeric;
        /* Array of ulined servers */
        std::list<Anope::string> Ulines;

        /* List of available opertypes */
        std::list<OperType *> MyOperTypes;
        /* List of pairs of opers and their opertype from the config */
        std::vector<Oper *> Opers;

        /* Map of fantasy commands */
        CommandInfo::map Fantasy;

        std::vector<CommandGroup> CommandGroups;
};

class ConfigException : public CoreException
{
 public:
        ConfigException() : CoreException("Config threw an exception", "Config Parser") { }
        ConfigException(const Anope::string &message) : CoreException(message, "Config Parser") { }
        virtual ~ConfigException() throw() { }
};

#define CONF_NO_ERROR 0x000000
#define CONF_NOT_A_NUMBER 0x000010
#define CONF_INT_NEGATIVE 0x000080
#define CONF_VALUE_NOT_FOUND 0x000100
#define CONF_FILE_NOT_FOUND 0x000200

class CoreExport ConfigReader
{
 protected:
        bool readerror;
        long error;
 public:
        ConfigReader();
        ConfigReader(const Anope::string &);
        ~ConfigReader();
        Anope::string ReadValue(const Anope::string &, const Anope::string &, int, bool = false);
        Anope::string ReadValue(const Anope::string &, const Anope::string &, const Anope::string &, int, bool = false);
        bool ReadFlag(const Anope::string &, const Anope::string &, int);
        bool ReadFlag(const Anope::string &, const Anope::string &, const Anope::string &, int);
        int ReadInteger(const Anope::string &, const Anope::string &, int, bool);
        int ReadInteger(const Anope::string &, const Anope::string &, const Anope::string &, int, bool);
        long GetError();
        int Enumerate(const Anope::string &) const;
        bool Verify();
        int EnumerateValues(const Anope::string &, int);
};

extern ConfigurationFile ServicesConf;
extern CoreExport ServerConfig *Config;

#endif // CONFIG_H