mode.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2004-2006, 2008 Craig Edwards <[email protected]>
 *   Copyright (C) 2007 Robin Burchell <[email protected]>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef MODE_H
#define MODE_H
 
#include "ctables.h"
 
enum ModeType
{
        MODETYPE_USER = 0,
        MODETYPE_CHANNEL = 1
};
 
enum ModeAction
{
        MODEACTION_DENY = 0, /* Drop the mode change, AND a parameter if its a parameterized mode */
        MODEACTION_ALLOW = 1 /* Allow the mode */
};
 
enum ModeMasks
{
        MASK_USER = 128,        /* A user mode */
        MASK_CHANNEL = 0        /* A channel mode */
};
 
enum PrefixModeValue
{
        /* +v */
        VOICE_VALUE     =       10000,
        /* +h */
        HALFOP_VALUE    =       20000,
        /* +o */
        OP_VALUE        =       30000
};
 
enum ParamSpec
{
        PARAM_NONE,
        PARAM_SETONLY,
        PARAM_ALWAYS
};
 
class CoreExport ModeHandler : public ServiceProvider
{
 protected:
        TranslateType m_paramtype;
 
        ParamSpec parameters_taken;
 
        char mode;
 
        char prefix;
 
        bool oper;
 
        bool list;
 
        ModeType m_type;
 
        int levelrequired;
 
 public:
        ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type);
        virtual CullResult cull();
        virtual ~ModeHandler();
        bool IsListMode();
        inline char GetPrefix() const { return prefix; }
        virtual unsigned int GetPrefixRank();
        inline ModeType GetModeType() const { return m_type; }
        inline TranslateType GetTranslateType() const { return m_paramtype; }
        inline bool NeedsOper() const { return oper; }
        int GetNumParams(bool adding);
        inline char GetModeChar() { return mode; }
 
        virtual std::string GetUserParameter(User* useor);
 
        virtual ModResult AccessCheck(User* source, Channel* channel, std::string &parameter, bool adding);
 
        virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding); /* Can change the mode parameter as its a ref */
        virtual void DisplayList(User* user, Channel* channel);
 
        virtual void OnParameterMissing(User* user, User* dest, Channel* channel);
 
        virtual void DisplayEmptyList(User* user, Channel* channel);
 
        virtual bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel* channel);
 
        virtual void RemoveMode(User* user, irc::modestacker* stack = NULL);
 
        virtual void RemoveMode(Channel* channel, irc::modestacker* stack = NULL);
 
        inline unsigned int GetLevelRequired() const { return levelrequired; }
};
 
class CoreExport SimpleUserModeHandler : public ModeHandler
{
 public:
        SimpleUserModeHandler(Module* Creator, const std::string& Name, char modeletter)
                : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER) {}
        virtual ~SimpleUserModeHandler() {}
        virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
};
 
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
 public:
        SimpleChannelModeHandler(Module* Creator, const std::string& Name, char modeletter)
                : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
        virtual ~SimpleChannelModeHandler() {}
        virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
};
 
class CoreExport ParamChannelModeHandler : public ModeHandler
{
 public:
        ParamChannelModeHandler(Module* Creator, const std::string& Name, char modeletter)
                : ModeHandler(Creator, Name, modeletter, PARAM_SETONLY, MODETYPE_CHANNEL) {}
        virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string &parameter, bool adding);
        virtual bool ParamValidate(std::string& parameter);
};
 
class CoreExport ModeWatcher : public classbase
{
 protected:
        char mode;
        ModeType m_type;
 
 public:
        ModuleRef creator;
        ModeWatcher(Module* creator, char modeletter, ModeType type);
        virtual ~ModeWatcher();
 
        char GetModeChar();
        ModeType GetModeType();
 
        virtual bool BeforeMode(User* source, User* dest, Channel* channel, std::string &parameter, bool adding, ModeType type);
        virtual void AfterMode(User* source, User* dest, Channel* channel, const std::string &parameter, bool adding, ModeType type);
};
 
typedef std::vector<ModeWatcher*>::iterator ModeWatchIter;
 
class CoreExport ModeParser
{
 private:
        ModeHandler* modehandlers[256];
        std::vector<ModeWatcher*> modewatchers[256];
        void DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text);
        void DisplayListModes(User* user, Channel* chan, std::string &mode_sequence);
 
        ModeAction TryMode(User* user, User* targu, Channel* targc, bool adding, unsigned char mode, std::string &param, bool SkipACL);
 
        std::string LastParse;
        std::vector<std::string> LastParseParams;
        std::vector<TranslateType> LastParseTranslate;
 
        unsigned int sent[256];
 
        unsigned int seq;
 
 public:
 
        ModeParser();
        ~ModeParser();
 
        User* SanityChecks(User *user,const char *dest,Channel *chan,int status);
        static void CleanMask(std::string &mask);
        const std::string& GetLastParse();
        const std::vector<std::string>& GetLastParseParams() { return LastParseParams; }
        const std::vector<TranslateType>& GetLastParseTranslate() { return LastParseTranslate; }
        bool AddMode(ModeHandler* mh);
        bool DelMode(ModeHandler* mh);
 
        bool AddModeWatcher(ModeWatcher* mw);
        bool DelModeWatcher(ModeWatcher* mw);
        void Process(const std::vector<std::string>& parameters, User *user, bool merge = false);
 
        ModeHandler* FindMode(unsigned const char modeletter, ModeType mt);
 
        ModeHandler* FindPrefix(unsigned const char pfxletter);
 
        std::string UserModeList();
 
        std::string ChannelModeList();
 
        std::string ParaModeList();
 
        std::string GiveModeList(ModeMasks m);
 
        static bool PrefixComparison(ModeHandler* one, ModeHandler* two);
 
        std::string BuildPrefixes(bool lettersAndModes = true);
};
 
#endif