regchannel.h

Go to the documentation of this file.

/*
 *
 * (C) 2008-2013 Anope Team
 * Contact us at team@anope.org
 *
 * Please read COPYING and README for further details.
 *
 */

#ifndef REGCHANNEL_H
#define REGCHANNEL_H

#include "memo.h"
#include "modes.h"
#include "extensible.h"
#include "logger.h"
#include "modules.h"
#include "serialize.h"
#include "bots.h"

typedef Anope::hash_map<ChannelInfo *> registered_channel_map;

extern CoreExport Serialize::Checker<registered_channel_map> RegisteredChannelList;

/* Indices for TTB (Times To Ban) */
enum
{
        TTB_BOLDS,
        TTB_COLORS,
        TTB_REVERSES,
        TTB_UNDERLINES,
        TTB_BADWORDS,
        TTB_CAPS,
        TTB_FLOOD,
        TTB_REPEAT,
        TTB_ITALICS,
        TTB_AMSGS,
        TTB_SIZE
};

enum BadWordType
{
        /* Always kicks if the word is said */
        BW_ANY,
        /* User must way the entire word */
        BW_SINGLE,
        /* The word has to start with the badword */
        BW_START,
        /* The word has to end with the badword */
        BW_END
};

/* Structure used to contain bad words. */
struct CoreExport BadWord : Serializable
{
        Serialize::Reference<ChannelInfo> ci;
        Anope::string word;
        BadWordType type;

        BadWord();
        ~BadWord();
        void Serialize(Serialize::Data &data) const anope_override;
        static Serializable* Unserialize(Serializable *obj, Serialize::Data &);
};

/* AutoKick data. */
class CoreExport AutoKick : public Serializable
{
 public:
        /* Channel this autokick is on */
        Serialize::Reference<ChannelInfo> ci;

        Anope::string mask;
        Serialize::Reference<NickCore> nc;

        Anope::string reason;
        Anope::string creator;
        time_t addtime;
        time_t last_used;

        AutoKick();
        ~AutoKick();
        void Serialize(Serialize::Data &data) const anope_override;
        static Serializable* Unserialize(Serializable *obj, Serialize::Data &);
};

struct CoreExport ModeLock : Serializable
{
 public:
        Serialize::Reference<ChannelInfo> ci;
        bool set;
        Anope::string name;
        Anope::string param;
        Anope::string setter;
        time_t created;

        ModeLock(ChannelInfo *ch, bool s, const Anope::string &n, const Anope::string &p, const Anope::string &se = "", time_t c = Anope::CurTime);
        ~ModeLock();

        void Serialize(Serialize::Data &data) const anope_override;
        static Serializable* Unserialize(Serializable *obj, Serialize::Data &);
};

struct CoreExport LogSetting : Serializable
{
        Serialize::Reference<ChannelInfo> ci;
        /* Our service name of the command */
        Anope::string service_name;
        /* The name of the client the command is on */
        Anope::string command_service;
        /* Name of the command to the user, can have spaces */
        Anope::string command_name;
        Anope::string method, extra;
        Anope::string creator;
        time_t created;

        LogSetting() : Serializable("LogSetting") { }
        void Serialize(Serialize::Data &data) const anope_override;
        static Serializable* Unserialize(Serializable *obj, Serialize::Data &);
};

/* It matters that Base is here before Extensible (it is inherited by Serializable)
 *
 * Possible flags:
 *     TOPICLOCK      - Topic can only be changed by TOPIC SET
 *     RESTRICTED     - Only users on the access list may join
 *     PEACE          - Don't allow ChanServ and BotServ commands to do bad things to users with higher access levels
 *     SECURE         - Don't allow any privileges
 *     NO_EXPIRE      - Channel does not expire
 *     MEMO_HARDMAX   - Channel memo limit may not be changed
 *     SECUREFOUNDER  - Stricter control of channel founder status
 *     SIGNKICK       - Sign kicks with the user who did the kick
 *     SIGNKICK_LEVEL - Sign kicks if level is < than the one defined by the SIGNKICK level
 *     SUSPENDED      - Channel is suepended
 *     PERSIST        - Channel still exists when empited (perm channel mode or leaving a botserv bot).
 *     STATS          - Chanstats are enabled
 *     NOAUTOOP       - If set users are not auto given any status on join
 *
 * BotServ flags:
 *     BS_DONTKICKOPS     - BotServ won't kick ops
 *     BS_DONTKICKVOICES  - BotServ won't kick voices
 *     BS_FANTASY         - BotServ bot accepts fantasy commands
 *     BS_GREET           - BotServ should show greets
 *     BS_NOBOT           - BotServ bots are not allowed to be in this channel
 *     BS_KICK_BOLDS      - BotServ kicks for bolds
 *     BS_KICK_COLORS     - BotServ kicks for colors
 *     BS_KICK_REVERSES   - BotServ kicks for reverses
 *     BS_KICK_UNDERLINES - BotServ kicks for underlines
 *     BS_KICK_BADWORD    - BotServ kicks for badwords
 *     BS_KICK_CAPS       - BotServ kicks for caps
 *     BS_KICK_FLOOD      - BotServ kicks for flood
 *     BS_KICK_REPEAT     - BotServ kicks for repeating
 *     BS_KICK_ITALICS    - BotServ kicks for italics
 *     BS_KICK_AMSGS      - BotServ kicks for amsgs
 */
class CoreExport ChannelInfo : public Serializable, public Extensible
{
 private:
        Serialize::Reference<NickCore> founder;                                 /* Channel founder */
        Serialize::Reference<NickCore> successor;                               /* Who gets the channel if the founder nick is dropped or expires */
        Serialize::Checker<std::vector<ChanAccess *> > access;                  /* List of authorized users */
        Serialize::Checker<std::vector<AutoKick *> > akick;                     /* List of users to kickban */
        Serialize::Checker<std::vector<BadWord *> > badwords;                   /* List of badwords */
        std::map<Anope::string, int16_t> levels;

 public:
        friend class ChanAccess;
        friend class AutoKick;
        friend struct BadWord;

        typedef std::multimap<Anope::string, ModeLock *> ModeList;
        Serialize::Checker<ModeList> mode_locks;
        Serialize::Checker<std::vector<LogSetting *> > log_settings;

        Anope::string name;                       /* Channel name */
        Anope::string desc;

        time_t time_registered;
        time_t last_used;

        Anope::string last_topic;                 /* The last topic that was set on this channel */
        Anope::string last_topic_setter;          /* Setter */
        time_t last_topic_time;                   /* Time */

        int16_t bantype;

        MemoInfo memos;

        Channel *c;                               /* Pointer to channel, if the channel exists */

        /* For BotServ */
        Serialize::Reference<BotInfo> bi;         /* Bot used on this channel */
        int16_t ttb[TTB_SIZE];                    /* Times to ban for each kicker */

        int16_t capsmin, capspercent;             /* For CAPS kicker */
        int16_t floodlines, floodsecs;            /* For FLOOD kicker */
        int16_t repeattimes;                      /* For REPEAT kicker */

        ChannelInfo(const Anope::string &chname);

        ChannelInfo(const ChannelInfo &ci);

        ~ChannelInfo();

        void Serialize(Serialize::Data &data) const anope_override;
        static Serializable* Unserialize(Serializable *obj, Serialize::Data &);

        void SetFounder(NickCore *nc);

        NickCore *GetFounder() const;

        void SetSuccessor(NickCore *nc);
        NickCore *GetSuccessor() const;

        BotInfo *WhoSends() const;

        void AddAccess(ChanAccess *access);

        ChanAccess *GetAccess(unsigned index) const;

        AccessGroup AccessFor(const User *u);
        AccessGroup AccessFor(const NickCore *nc);

        unsigned GetAccessCount() const;

        void EraseAccess(unsigned index);

        void ClearAccess();

        AutoKick* AddAkick(const Anope::string &user, NickCore *akicknc, const Anope::string &reason, time_t t = Anope::CurTime, time_t lu = 0);

        AutoKick* AddAkick(const Anope::string &user, const Anope::string &mask, const Anope::string &reason, time_t t = Anope::CurTime, time_t lu = 0);

        AutoKick* GetAkick(unsigned index) const;

        unsigned GetAkickCount() const;

        void EraseAkick(unsigned index);

        void ClearAkick();

        BadWord* AddBadWord(const Anope::string &word, BadWordType type);

        BadWord* GetBadWord(unsigned index) const;

        unsigned GetBadWordCount() const;

        void EraseBadWord(unsigned index);

        void ClearBadWords();

        bool HasMLock(ChannelMode *mode, const Anope::string &param, bool status) const;

        bool SetMLock(ChannelMode *mode, bool status, const Anope::string &param = "", Anope::string setter = "", time_t created = Anope::CurTime);

        bool RemoveMLock(ChannelMode *mode, bool status, const Anope::string &param = "");

        void RemoveMLock(ModeLock *mlock);

        void ClearMLock();

        const ModeList &GetMLock() const;

        std::pair<ModeList::iterator, ModeList::iterator> GetModeList(const Anope::string &name);

        const ModeLock *GetMLock(const Anope::string &mname, const Anope::string &param = "");

        Anope::string GetMLockAsString(bool complete) const;

        bool CheckKick(User *user);

        void CheckTopic();

        void RestoreTopic();

        int16_t GetLevel(const Anope::string &priv) const;

        void SetLevel(const Anope::string &priv, int16_t level);

        void RemoveLevel(const Anope::string &priv);

        void ClearLevels();

        Anope::string GetIdealBan(User *u) const;

        static ChannelInfo* Find(const Anope::string &name);
};

extern CoreExport bool IsFounder(const User *user, const ChannelInfo *ci);

#endif // REGCHANNEL_H