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

channels.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 __CHANNELS_H__
#define __CHANNELS_H__

enum ChannelModes {
        CM_TOPICLOCK = 't'-65,  /* +t: Only operators can change topic */
        CM_NOEXTERNAL = 'n'-65, /* +n: Only users in the channel can message it */
        CM_INVITEONLY = 'i'-65, /* +i: Invite only */
        CM_MODERATED = 'm'-65,  /* +m: Only voices and above can talk */
        CM_SECRET = 's'-65,     /* +s: Secret channel */
        CM_PRIVATE = 'p'-65,    /* +p: Private channel */
        CM_KEY = 'k'-65,        /* +k: Keyed channel */
        CM_LIMIT = 'l'-65       /* +l: Maximum user limit */
};

/* Forward declarations - needed */
class User;

class HostItem : public classbase
{
 public:
        time_t set_time;
        std::string set_by;
        std::string data;

        HostItem() { /* stub */ }
        virtual ~HostItem() { /* stub */ }
};

class BanItem : public HostItem
{
};

typedef std::vector<BanItem>    BanList;

typedef std::map<User*,std::string> CUList;

typedef CUList::iterator CUListIter;

typedef CUList::const_iterator CUListConstIter;

typedef std::map<char,char*> CustomModeList;


enum UserChannelModes {
        UCMODE_OP       = 1,    /* Opped user */
        UCMODE_VOICE    = 2,    /* Voiced user */
        UCMODE_HOP      = 4     /* Halfopped user */
};

typedef std::pair<char, unsigned int> prefixtype;

typedef std::vector<prefixtype> pfxcontainer;

typedef std::map<User*, std::vector<prefixtype> > prefixlist;

class CoreExport Channel : public Extensible
{
 private:

        InspIRCd* ServerInstance;

        static Channel* ForceChan(InspIRCd* Instance, Channel* Ptr, User* user, const std::string &privs, bool bursting);

        void SetDefaultModes();

        prefixlist prefixes;

        int maxbans;

 public:
        Channel(InspIRCd* Instance, const std::string &name, time_t ts);

        std::string name; /* CHANMAX */

        std::bitset<64> modes;

        CUList internal_userlist;

        CUList internal_op_userlist;

        CUList internal_halfop_userlist;

        CUList internal_voice_userlist;

        CustomModeList custom_mode_params;

        std::string topic; /* MAXTOPIC */

        time_t created;

        time_t topicset;

        std::string setby; /* 128 */

        BanList bans;
        
        void SetMode(char mode,bool mode_on);

        void SetModeParam(char mode,const char* parameter,bool mode_on);
 
        bool IsModeSet(char mode);

        std::string GetModeParameter(char mode);

        int SetTopic(User *u, std::string &t, bool forceset = false);

        long GetUserCounter();

        void AddUser(User* user);

        void AddOppedUser(User* user);

        void AddHalfoppedUser(User* user);

        void AddVoicedUser(User* user);

        unsigned long DelUser(User* user);

        void DelOppedUser(User* user);

        void DelHalfoppedUser(User* user);

        void DelVoicedUser(User* user);

        CUList* GetUsers();

        CUList* GetOppedUsers();

        CUList* GetHalfoppedUsers();

        CUList* GetVoicedUsers();

        bool HasUser(User* user);

        long KickUser(User *src, User *user, const char* reason);

        long ServerKickUser(User* user, const char* reason, bool triggerevents, const char* servername = NULL);

        long PartUser(User *user, std::string &reason);

        /* Join a user to a channel. May be a channel that doesnt exist yet.
         * @param user The user to join to the channel.
         * @param cn The channel name to join to. Does not have to exist.
         * @param key The key of the channel, if given
         * @param override If true, override all join restrictions such as +bkil
         * @return A pointer to the Channel the user was joined to. A new Channel may have
         * been created if the channel did not exist before the user was joined to it.
         * If the user could not be joined to a channel, the return value may be NULL.
         */
        static Channel* JoinUser(InspIRCd* ServerInstance, User *user, const char* cn, bool override, const char* key, bool bursting, time_t TS = 0);

        void WriteChannel(User* user, const char* text, ...) CUSTOM_PRINTF(3, 4);

        void WriteChannel(User* user, const std::string &text);

        void WriteChannelWithServ(const char* ServName, const char* text, ...) CUSTOM_PRINTF(3, 4);

        void WriteChannelWithServ(const char* ServName, const std::string &text);

        void WriteAllExceptSender(User* user, bool serversource, char status, const char* text, ...) CUSTOM_PRINTF(5, 6);

        void WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const char* text, ...) CUSTOM_PRINTF(6, 7);

        void WriteAllExceptSender(User* user, bool serversource, char status, const std::string& text);

        void WriteAllExcept(User* user, bool serversource, char status, CUList &except_list, const std::string& text);

        long GetMaxBans();

        char* ChanModes(bool showkey);

        void UserList(User *user, CUList* ulist = NULL);

        int CountInvisible();

        int GetStatus(User *user);

        int GetStatusFlags(User *user);

        const char* GetPrefixChar(User *user);

        const char* GetAllPrefixChars(User* user);

        unsigned int GetPrefixValue(User* user);

        void RemoveAllPrefixes(User* user);

        void SetPrefix(User* user, char prefix, unsigned int prefix_rank, bool adding);

        bool IsBanned(User* user);

        bool IsExtBanned(User *u, char type);

        bool IsExtBanned(const std::string &str, char type);

        void ResetMaxBans();

        virtual ~Channel() { /* stub */ }
};

#endif