modes.h

Go to the documentation of this file.

/* Mode support
 *
 * Copyright (C) 2008-2011 Adam <Adam@anope.org>
 * Copyright (C) 2008-2013 Anope Team <team@anope.org>
 *
 * Please read COPYING and README for further details.
 */

#ifndef MODES_H
#define MODES_H

#include "anope.h"
#include "base.h"

enum ModeType
{
        /* Regular mode */
        MODE_REGULAR,
        /* b/e/I */
        MODE_LIST,
        /* k/l etc */
        MODE_PARAM,
        /* v/h/o/a/q */
        MODE_STATUS
};

/* Classes of modes, Channel modes and User modes
 */
enum ModeClass
{
        MC_CHANNEL,
        MC_USER
};

class CoreExport Mode : public Base
{
 public:
        /* Mode name */
        Anope::string name;
        /* Class of mode this is (user/channel) */
        ModeClass mclass;
        /* Mode char for this, eg 'b' */
        char mchar;
        /* Type of mode this is, eg MODE_LIST */
        ModeType type;

        Mode(const Anope::string &mname, ModeClass mclass, char mc, ModeType type);
        virtual ~Mode();
};

class CoreExport UserMode : public Mode
{
 public:
        UserMode(const Anope::string &name, char mc);
        virtual ~UserMode();
};

class CoreExport UserModeParam : public UserMode
{
 public:
        UserModeParam(const Anope::string &name, char mc);

        virtual bool IsValid(const Anope::string &value) const { return true; }
};

class CoreExport ChannelMode : public Mode
{
 public:
        ChannelMode(const Anope::string &name, char mc);
        virtual ~ChannelMode();

        virtual bool CanSet(User *u) const;
};


class CoreExport ChannelModeList : public ChannelMode
{
 public:
        ChannelModeList(const Anope::string &name, char mc);

        virtual ~ChannelModeList();

        virtual bool IsValid(const Anope::string &mask) const { return true; }

        virtual bool Matches(const User *u, const Entry *e) { return false; }

        virtual void OnAdd(Channel *chan, const Anope::string &mask) { }

        virtual void OnDel(Channel *chan, const Anope::string &mask) { }
};

class CoreExport ChannelModeParam : public ChannelMode
{
 public:
        ChannelModeParam(const Anope::string &name, char mc, bool minus_no_arg = false);

        virtual ~ChannelModeParam();

        /* Should we send an arg when unsetting this mode? */
        bool minus_no_arg;

        virtual bool IsValid(const Anope::string &value) const { return true; }
};

class CoreExport ChannelModeStatus : public ChannelMode
{
 public:
        /* The symbol, eg @ % + */
        char Symbol;
        /* The "level" of the mode, used to compare with other modes.
         * Used so we know op > halfop > voice etc.
         */
        short level;

        ChannelModeStatus(const Anope::string &name, char mc, char mSymbol, short mlevel = 0);

        virtual ~ChannelModeStatus();
};

/* The status a user has on a channel (+v, +h, +o) etc */
class CoreExport ChannelStatus
{
 public:
        std::set<Anope::string> modes;
        Anope::string BuildCharPrefixList() const;
        Anope::string BuildModePrefixList() const;
};

class CoreExport ChannelModeKey : public ChannelModeParam
{
 public:
        ChannelModeKey(char mc) : ChannelModeParam("KEY", mc) { }

        bool IsValid(const Anope::string &value) const anope_override;
};

class CoreExport ChannelModeAdmin : public ChannelMode
{
 public:
        ChannelModeAdmin(char mc) : ChannelMode("ADMINONLY", mc) { }

        /* Opers only */
        bool CanSet(User *u) const anope_override;
};

class CoreExport ChannelModeOper : public ChannelMode
{
 public:
        ChannelModeOper(char mc) : ChannelMode("OPERONLY", mc) { }

        /* Opers only */
        bool CanSet(User *u) const anope_override;
};

class CoreExport ChannelModeRegistered : public ChannelMode
{
 public:
        ChannelModeRegistered(char mc) : ChannelMode("REGISTERED", mc) { }

        /* No one mlocks +r */
        bool CanSet(User *u) const anope_override;
};

class StackerInfo
{
 public:
        /* Modes to be added */
        std::list<std::pair<Mode *, Anope::string> > AddModes;
        /* Modes to be deleted */
        std::list<std::pair<Mode *, Anope::string> > DelModes;
        /* Bot this is sent from */
        const BotInfo *bi;

        void AddMode(Mode *mode, bool set, const Anope::string &param);
};

class CoreExport ModeManager
{
 protected:
        /* List of pairs of user/channels and their stacker info */
        static std::map<User *, StackerInfo *> UserStackerObjects;
        static std::map<Channel *, StackerInfo *> ChannelStackerObjects;

        static std::list<Anope::string> BuildModeStrings(StackerInfo *info);

 public:
        /* List of all modes Anope knows about */
        static std::vector<ChannelMode *> ChannelModes;
        static std::vector<UserMode *> UserModes;

        /* Number of generic channel and user modes we are tracking */
        static unsigned GenericChannelModes;
        static unsigned GenericUserModes;
        /* Default channel mode lock */
        static std::list<std::pair<Anope::string, Anope::string> > ModeLockOn;
        static std::list<Anope::string> ModeLockOff;
        /* Default modes bots have on channels */
        static ChannelStatus DefaultBotModes;

        static bool AddUserMode(UserMode *um);

        static bool AddChannelMode(ChannelMode *cm);

        static void RemoveUserMode(UserMode *um);

        static void RemoveChannelMode(ChannelMode *cm);

        static ChannelMode *FindChannelModeByChar(char mode);

        static UserMode *FindUserModeByChar(char mode);

        static ChannelMode *FindChannelModeByName(const Anope::string &name);

        static UserMode *FindUserModeByName(const Anope::string &name);

        static char GetStatusChar(char symbol);

        static void StackerAdd(const BotInfo *bi, Channel *c, ChannelMode *cm, bool set, const Anope::string &param = "");

        static void StackerAdd(const BotInfo *bi, User *u, UserMode *um, bool set, const Anope::string &param = "");

        static void ProcessModes();

        static void StackerDel(User *u);
        static void StackerDel(Channel *c);
        static void StackerDel(Mode *m);

        static void UpdateDefaultMLock(ServerConfig *config);
};

class CoreExport Entry
{
        Anope::string name;
        Anope::string mask;
 public:
        unsigned short cidr_len;
        Anope::string nick, user, host, real;

        Entry(const Anope::string &mode, const Anope::string &host);

        const Anope::string GetMask() const;

        bool Matches(const User *u, bool full = false) const;
};

#endif // MODES_H