#pragma once
#include "ctables.h"
+#include "modechange.h"
/**
* Holds the values for different type of modes
MODEACTION_ALLOW = 1 /* Allow the mode */
};
-/**
- * Used to mask off the mode types in the mode handler
- * array. Used in a simple two instruction hashing function
- * "(modeletter - 65) OR mask"
- */
-enum ModeMasks
-{
- MASK_USER = 128, /* A user mode */
- MASK_CHANNEL = 0 /* A channel mode */
-};
-
/**
* These fixed values can be used to proportionally compare module-defined prefixes to known values.
* For example, if your module queries a Channel, and is told that user 'joebloggs' has the prefix
class PrefixMode;
class ListModeBase;
+class ParamModeBase;
/** Each mode is implemented by ONE ModeHandler class.
* You must derive ModeHandler and add the child class to
class CoreExport ModeHandler : public ServiceProvider
{
public:
+ typedef size_t Id;
+
enum Class
{
MC_PREFIX,
MC_LIST,
+ MC_PARAM,
MC_OTHER
};
- protected:
- /**
- * The mode parameter translation type
+ private:
+ /** The opaque id of this mode assigned by the mode parser
*/
- TranslateType m_paramtype;
+ Id modeid;
+ protected:
/** What kind of parameters does the mode take?
*/
ParamSpec parameters_taken;
*/
const Class type_id;
- /** The prefix char needed on channel to use this mode,
- * only checked for channel modes
- */
- int levelrequired;
+ /** The prefix rank required to set this mode on channels. */
+ unsigned int ranktoset;
+
+ /** The prefix rank required to unset this mode on channels. */
+ unsigned int ranktounset;
public:
/**
* @param mclass The object type of this mode handler, one of ModeHandler::Class
*/
ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type, Class mclass = MC_OTHER);
- virtual CullResult cull();
+ CullResult cull() CXX11_OVERRIDE;
virtual ~ModeHandler();
+
+ /** Register this object in the ModeParser
+ */
+ void RegisterService() CXX11_OVERRIDE;
+
/**
* Returns true if the mode is a list mode
*/
*/
PrefixMode* IsPrefixMode();
+ /**
+ * Check whether this mode is a prefix mode
+ * @return non-NULL if this mode is a prefix mode, NULL otherwise
+ */
+ const PrefixMode* IsPrefixMode() const;
+
/**
* Check whether this mode handler inherits from ListModeBase
* @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise
ListModeBase* IsListModeBase();
/**
- * Returns the mode's type
+ * Check whether this mode handler inherits from ListModeBase
+ * @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise
*/
- inline ModeType GetModeType() const { return m_type; }
+ const ListModeBase* IsListModeBase() const;
+
/**
- * Returns the mode's parameter translation type
+ * Check whether this mode handler inherits from ParamModeBase
+ * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
*/
- inline TranslateType GetTranslateType() const { return m_paramtype; }
+ ParamModeBase* IsParameterMode();
+
+ /**
+ * Check whether this mode handler inherits from ParamModeBase
+ * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
+ */
+ const ParamModeBase* IsParameterMode() const;
+
+ /**
+ * Returns the mode's type
+ */
+ inline ModeType GetModeType() const { return m_type; }
/**
* Returns true if the mode can only be set/unset by an oper
*/
inline bool NeedsOper() const { return oper; }
/**
- * Returns the number of parameters for the mode. Any non-zero
- * value should be considered to be equivalent to one.
- * @param adding If this is true, the number of parameters required to set the mode should be returned, otherwise the number of parameters required to unset the mode shall be returned.
- * @return The number of parameters the mode expects
+ * Check if the mode needs a parameter for adding or removing
+ * @param adding True to check if the mode needs a parameter when setting, false to check if the mode needs a parameter when unsetting
+ * @return True if the mode needs a parameter for the specified action, false if it doesn't
*/
- int GetNumParams(bool adding);
+ bool NeedsParam(bool adding) const;
/**
* Returns the mode character this handler handles.
* @return The mode character
*/
- inline char GetModeChar() { return mode; }
+ char GetModeChar() const { return mode; }
+
+ /** Return the id of this mode which is used in User::modes and
+ * Channel::modes as the index to determine whether a mode is set.
+ */
+ Id GetId() const { return modeid; }
/** For user modes, return the current parameter, if any
*/
- virtual std::string GetUserParameter(User* useor);
+ virtual std::string GetUserParameter(const User* user) const;
/**
* Called when a channel mode change access check for your mode occurs.
* so if you inherit from it or your mode can be removed by the default implementation then you do not have to implement
* this function).
* @param channel The channel which the server wants to remove your mode from
- * @param stack The mode stack to add the mode change to
+ * @param changelist Mode change list to populate with the removal of this mode
+ */
+ virtual void RemoveMode(Channel* channel, Modes::ChangeList& changelist);
+
+ /** Retrieves the level required to modify this mode.
+ * @param adding Whether the mode is being added or removed.
*/
- virtual void RemoveMode(Channel* channel, irc::modestacker& stack);
+ inline unsigned int GetLevelRequired(bool adding) const
+ {
+ return adding ? ranktoset : ranktounset;
+ }
- inline unsigned int GetLevelRequired() const { return levelrequired; }
+ friend class ModeParser;
};
/**
*/
unsigned int prefixrank;
+ /** Whether a client with this prefix can remove it from themself. */
+ bool selfremove;
+
public:
/**
* Constructor
* @param Creator The module creating this mode
* @param Name The user-friendly one word name of the prefix mode, e.g.: "op", "voice"
* @param ModeLetter The mode letter of this mode
+ * @param Rank Rank given by this prefix mode, see explanation above
+ * @param PrefixChar Prefix character, or 0 if the mode has no prefix character
*/
- PrefixMode(Module* Creator, const std::string& Name, char ModeLetter);
+ PrefixMode(Module* Creator, const std::string& Name, char ModeLetter, unsigned int Rank = 0, char PrefixChar = 0);
+
+ /**
+ * Called when a channel mode change access check for your mode occurs.
+ * @param source Contains the user setting the mode.
+ * @param channel contains the destination channel the modes are being set on.
+ * @param parameter The parameter for your mode. This is modifiable.
+ * @param adding This value is true when the mode is being set, or false when it is being unset.
+ * @return allow, deny, or passthru to check against the required level
+ */
+ ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding) CXX11_OVERRIDE;
/**
* Handles setting and unsetting the prefix mode.
* The latter occurs either when the member cannot be found or when the member already has this prefix set
* (when setting) or doesn't have this prefix set (when unsetting).
*/
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& param, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& param, bool adding) CXX11_OVERRIDE;
+
+ /**
+ * Updates the configuration of this prefix.
+ * @param rank The prefix rank of this mode.
+ * @param setrank The prefix rank required to set this mode on channels.
+ * @param unsetrank The prefix rank required to set this unmode on channels.
+ * @param selfrm Whether a client with this prefix can remove it from themself.
+ */
+ void Update(unsigned int rank, unsigned int setrank, unsigned int unsetrank, bool selfrm);
/**
* Removes this prefix mode from all users on the given channel
- * @param chan The channel which the server wants to remove your mode from
- * @param stack The mode stack to add the mode change to
+ * @param channel The channel which the server wants to remove your mode from
+ * @param changelist Mode change list to populate with the removal of this mode
*/
- void RemoveMode(Channel* chan, irc::modestacker& stack);
+ void RemoveMode(Channel* channel, Modes::ChangeList& changelist) CXX11_OVERRIDE;
+
+
+ /**
+ * Determines whether a user with this prefix mode can remove it.
+ */
+ bool CanSelfRemove() const { return selfremove; }
/**
* Mode prefix or 0. If this is defined, you should
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 ¶meter, bool adding);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
};
/** A prebuilt mode handler which handles a simple channel mode, e.g. no parameters, usable by any user, with no extra
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 ¶meter, 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 ¶meter, bool adding);
- /** Validate the parameter - you may change the value to normalize it. Return true if it is valid. */
- virtual bool ParamValidate(std::string& parameter);
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE;
};
/**
* Get the mode type being watched
* @return The mode type being watched (user or channel)
*/
- ModeType GetModeType();
+ ModeType GetModeType() const { return m_type; }
/**
* Before the mode character is processed by its handler, this method will be called.
virtual void AfterMode(User* source, User* dest, Channel* channel, const std::string& parameter, bool adding);
};
-typedef std::multimap<std::string, ModeWatcher*>::iterator ModeWatchIter;
-
/** The mode parser handles routing of modes and handling of mode strings.
* It marshalls, controls and maintains both ModeWatcher and ModeHandler classes,
* parses client to server MODE strings for user and channel modes, and performs
* processing for the 004 mode list numeric, amongst other things.
*/
-class CoreExport ModeParser
+class CoreExport ModeParser : public fakederef<ModeParser>
{
+ public:
+ static const ModeHandler::Id MODEID_MAX = 64;
+
+ /** Type of the container that maps mode names to ModeHandlers
+ */
+ typedef TR1NS::unordered_map<std::string, ModeHandler*, irc::insensitive, irc::StrHashComp> ModeHandlerMap;
+
private:
+ /** Type of the container that maps mode names to ModeWatchers
+ */
+ typedef insp::flat_multimap<std::string, ModeWatcher*> ModeWatcherMap;
+
+ /** Last item in the ModeType enum
+ */
+ static const unsigned int MODETYPE_LAST = 2;
+
/** Mode handlers for each mode, to access a handler subtract
* 65 from the ascii value of the mode letter.
* The upper bit of the value indicates if its a usermode
* or a channel mode, so we have 256 of them not 64.
*/
- ModeHandler* modehandlers[256];
+ ModeHandler* modehandlers[MODETYPE_LAST][128];
+
+ /** An array of mode handlers indexed by the mode id
+ */
+ ModeHandler* modehandlersbyid[MODETYPE_LAST][MODEID_MAX];
+
+ /** A map of mode handlers keyed by their name
+ */
+ ModeHandlerMap modehandlersbyname[MODETYPE_LAST];
/** Lists of mode handlers by type
*/
/** Mode watcher classes
*/
- std::multimap<std::string, ModeWatcher*> modewatchermap;
+ ModeWatcherMap modewatchermap;
- /** Displays the current modes of a channel or user.
- * Used by ModeParser::Process.
- */
- void DisplayCurrentModes(User *user, User* targetuser, Channel* targetchannel, const char* text);
- /** Displays the value of a list mode
- * Used by ModeParser::Process.
+ /** Last processed mode change
*/
- void DisplayListModes(User* user, Channel* chan, std::string &mode_sequence);
+ Modes::ChangeList LastChangeList;
/**
* Attempts to apply a mode change to a user or channel
*/
- ModeAction TryMode(User* user, User* targu, Channel* targc, bool adding, unsigned char mode, std::string ¶m, bool SkipACL);
+ ModeAction TryMode(User* user, User* targu, Channel* targc, Modes::Change& mcitem, bool SkipACL);
/** Returns a list of user or channel mode characters.
* Used for constructing the parts of the mode list in the 004 numeric.
*/
void RecreateModeListFor004Numeric();
- /** The string representing the last set of modes to be parsed.
- * Use GetLastParse() to get this value, to be used for display purposes.
+ /** Allocates an unused id for the given mode type, throws a ModuleException if out of ids.
+ * @param mt The type of the mode to allocate the id for
+ * @return The id
*/
- std::string LastParse;
- std::vector<std::string> LastParseParams;
- std::vector<TranslateType> LastParseTranslate;
-
- unsigned int sent[256];
-
- unsigned int seq;
+ ModeHandler::Id AllocateModeId(ModeType mt);
/** Cached mode list for use in 004 numeric
*/
- std::string Cached004ModeList;
+ TR1NS::array<std::string, 3> Cached004ModeList;
public:
typedef std::vector<ListModeBase*> ListModeList;
*/
MODE_MERGE = 1,
- /** If this flag is set then the mode change won't be handed over to
- * the linking module to be sent to other servers, but will be processed
+ /** If this flag is set then the linking module will ignore the mode change
+ * and not send it to other servers. The mode change will be processed
* locally and sent to local user(s) as usual.
*/
- MODE_LOCALONLY = 2
+ MODE_LOCALONLY = 2,
+
+ /** If this flag is set then the mode change will be subject to access checks.
+ * For more information see the documentation of the PrefixMode class,
+ * ModeHandler::ranktoset and ModeHandler::AccessCheck().
+ * Modules may explicitly allow a mode change regardless of this flag by returning
+ * MOD_RES_ALLOW from the OnPreMode hook. Only affects channel mode changes.
+ */
+ MODE_CHECKACCESS = 4
};
ModeParser();
~ModeParser();
- /** Initialize all built-in modes
- */
- static void InitBuiltinModes();
+ static bool IsModeChar(char chr);
/** Tidy a banmask. This makes a banmask 'acceptable' if fields are left out.
* E.g.
* This method can be used on both IPV4 and IPV6 user masks.
*/
static void CleanMask(std::string &mask);
- /** Get the last string to be processed, as it was sent to the user or channel.
- * Use this to display a string you just sent to be parsed, as the actual output
- * may be different to what you sent after it has been 'cleaned up' by the parser.
- * @return Last parsed string, as seen by users.
- */
- const std::string& GetLastParse() const { return LastParse; }
- const std::vector<std::string>& GetLastParseParams() { return LastParseParams; }
- const std::vector<TranslateType>& GetLastParseTranslate() { return LastParseTranslate; }
+
+ /** Gets the last mode change to be processed. */
+ const Modes::ChangeList& GetLastChangeList() const { return LastChangeList; }
+
/** Add a mode to the mode parser.
- * @return True if the mode was successfully added.
+ * Throws a ModuleException if the mode cannot be added.
*/
- bool AddMode(ModeHandler* mh);
+ void AddMode(ModeHandler* mh);
+
/** Delete a mode from the mode parser.
* When a mode is deleted, the mode handler will be called
* for every user (if it is a user mode) or for every channel
* @return True if the ModeWatcher was deleted correctly
*/
bool DelModeWatcher(ModeWatcher* mw);
- /** Process a set of mode changes from a server or user.
- * @param parameters The parameters of the mode change, in the format
- * they would be from a MODE command.
+
+ /** Process a list of mode changes entirely. If the mode changes do not fit into one MODE line
+ * then multiple MODE lines are generated.
* @param user The source of the mode change, can be a server user.
+ * @param targetchannel Channel to apply the mode change on. NULL if changing modes on a channel.
+ * @param targetuser User to apply the mode change on. NULL if changing modes on a user.
+ * @param changelist Modes to change in form of a Modes::ChangeList.
* @param flags Optional flags controlling how the mode change is processed,
* defaults to MODE_NONE.
*/
- void Process(const std::vector<std::string>& parameters, User* user, ModeProcessFlag flags = MODE_NONE);
+ void Process(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags = MODE_NONE);
+
+ /** Process a single MODE line's worth of mode changes, taking max modes and line length limits
+ * into consideration. Return value indicates how many modes were processed.
+ * @param user The source of the mode change, can be a server user.
+ * @param targetchannel Channel to apply the mode change on. NULL if changing modes on a channel.
+ * @param targetuser User to apply the mode change on. NULL if changing modes on a user.
+ * @param changelist Modes to change in form of a Modes::ChangeList. May not process
+ * the entire list due to MODE line length and max modes limitations.
+ * @param flags Optional flags controlling how the mode change is processed,
+ * defaults to MODE_NONE.
+ * @param beginindex Index of the first element in changelist to process. Mode changes before
+ * the element with this index are ignored.
+ * @return Number of mode changes processed from changelist.
+ */
+ unsigned int ProcessSingle(User* user, Channel* targetchannel, User* targetuser, Modes::ChangeList& changelist, ModeProcessFlag flags = MODE_NONE, unsigned int beginindex = 0);
+
+ /** Turn a list of parameters compatible with the format of the MODE command into
+ * Modes::ChangeList form. All modes are processed, regardless of max modes. Unknown modes
+ * are skipped.
+ * @param user The source of the mode change, can be a server user. Error numerics are sent to
+ * this user.
+ * @param type MODETYPE_USER if this is a user mode change or MODETYPE_CHANNEL if this
+ * is a channel mode change.
+ * @param parameters List of strings describing the mode change to convert to a ChangeList.
+ * Must be using the same format as the parameters of a MODE command.
+ * @param changelist ChangeList object to populate.
+ * @param beginindex Index of the first element that is part of the MODE list in the parameters
+ * container. Defaults to 1.
+ * @param endindex Index of the first element that is not part of the MODE list. By default,
+ * the entire container is considered part of the MODE list.
+ */
+ void ModeParamsToChangeList(User* user, ModeType type, const std::vector<std::string>& parameters, Modes::ChangeList& changelist, unsigned int beginindex = 1, unsigned int endindex = UINT_MAX);
+
+ /** Find the mode handler for a given mode name and type.
+ * @param modename The mode name to search for.
+ * @param mt Type of mode to search for, user or channel.
+ * @return A pointer to a ModeHandler class, or NULL of there isn't a handler for the given mode name.
+ */
+ ModeHandler* FindMode(const std::string& modename, ModeType mt);
/** Find the mode handler for a given mode and type.
* @param modeletter mode letter to search for
*/
PrefixMode* FindPrefix(unsigned const char pfxletter);
- /** Returns a list of modes, space seperated by type:
+ /** Returns an array of modes:
* 1. User modes
* 2. Channel modes
* 3. Channel modes that require a parameter when set
* This is sent to users as the last part of the 004 numeric
*/
- const std::string& GetModeListFor004Numeric();
+ const TR1NS::array<std::string, 3>& GetModeListFor004Numeric();
/** Generates a list of modes, comma seperated by type:
* 1; Listmodes EXCEPT those with a prefix
* 3; Modes that only take a param when adding
* 4; Modes that dont take a param
*/
- std::string GiveModeList(ModeMasks m);
+ std::string GiveModeList(ModeType mt);
/** This returns the PREFIX=(ohv)@%+ section of the 005 numeric, or
* just the "@%+" part if the parameter false
* @return A list containing all prefix modes
*/
const PrefixModeList& GetPrefixModes() const { return mhlist.prefix; }
+
+ /** Get a mode name -> ModeHandler* map containing all modes of the given type
+ * @param mt Type of modes to return, MODETYPE_USER or MODETYPE_CHANNEL
+ * @return A map of mode handlers of the given type
+ */
+ const ModeHandlerMap& GetModes(ModeType mt) const { return modehandlersbyname[mt]; }
+
+ /** Show the list of a list mode to a user. Modules can deny the listing.
+ * @param user User to show the list to.
+ * @param chan Channel to show the list of.
+ * @param mh List mode to show the list of.
+ */
+ void ShowListModeList(User* user, Channel* chan, ModeHandler* mh);
};
-inline const std::string& ModeParser::GetModeListFor004Numeric()
+inline const TR1NS::array<std::string, 3>& ModeParser::GetModeListFor004Numeric()
{
return Cached004ModeList;
}
return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : NULL);
}
+inline const PrefixMode* ModeHandler::IsPrefixMode() const
+{
+ return (this->type_id == MC_PREFIX ? static_cast<const PrefixMode*>(this) : NULL);
+}
+
inline ListModeBase* ModeHandler::IsListModeBase()
{
return (this->type_id == MC_LIST ? reinterpret_cast<ListModeBase*>(this) : NULL);
}
+
+inline const ListModeBase* ModeHandler::IsListModeBase() const
+{
+ return (this->type_id == MC_LIST ? reinterpret_cast<const ListModeBase*>(this) : NULL);
+}
+
+inline ParamModeBase* ModeHandler::IsParameterMode()
+{
+ return (this->type_id == MC_PARAM ? reinterpret_cast<ParamModeBase*>(this) : NULL);
+}
+
+inline const ParamModeBase* ModeHandler::IsParameterMode() const
+{
+ return (this->type_id == MC_PARAM ? reinterpret_cast<const ParamModeBase*>(this) : NULL);
+}
projects / user / henk / code / inspircd.git / blobdiff