/*
* InspIRCd -- Internet Relay Chat Daemon
*
+ * Copyright (C) 2013-2016 Attila Molnar <attilamolnar@hush.com>
+ * Copyright (C) 2012-2013, 2017-2021 Sadie Powell <sadie@witchery.services>
+ * Copyright (C) 2012 Robby <robby@chatbelgie.be>
* Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
- * Copyright (C) 2004-2006, 2008 Craig Edwards <craigedwards@brainbox.cc>
- * Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
+ * Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
+ * Copyright (C) 2007-2008 Robin Burchell <robin+git@viroteck.net>
* Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
+ * Copyright (C) 2006-2008, 2010 Craig Edwards <brain@inspircd.org>
*
* 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
Id modeid;
protected:
- /**
- * The mode parameter translation type
- */
- TranslateType m_paramtype;
-
/** What kind of parameters does the mode take?
*/
ParamSpec parameters_taken;
* inside the mode parser as in the 1.0 api,
* so the only use of this value (along with
* IsListMode()) is for the core to determine
- * wether your module can produce 'lists' or not
+ * whether your module can produce 'lists' or not
* (e.g. banlists, etc)
*/
bool list;
*/
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;
+
+ /** If non-empty then the syntax of the parameter for this mode. */
+ std::string syntax;
public:
/**
- * The constructor for ModeHandler initalizes the mode handler.
+ * The constructor for ModeHandler initializes the mode handler.
* The constructor of any class you derive from ModeHandler should
* probably call this constructor with the parameters set correctly.
* @param me The module which created this mode
* @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
/**
* Check whether this mode handler inherits from ListModeBase
+ * @return non-NULL if this mode handler inherits from ListModeBase, NULL otherwise
+ */
+ const ListModeBase* IsListModeBase() const;
+
+ /**
+ * Check whether this mode handler inherits from ParamModeBase
* @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
*/
ParamModeBase* IsParameterMode();
/**
- * Returns the mode's type
+ * Check whether this mode handler inherits from ParamModeBase
+ * @return non-NULL if this mode handler inherits from ParamModeBase, NULL otherwise
*/
- inline ModeType GetModeType() const { return m_type; }
+ const ParamModeBase* IsParameterMode() const;
+
/**
- * Returns the mode's parameter translation type
+ * Returns the mode's type
*/
- inline TranslateType GetTranslateType() const { return m_paramtype; }
+ 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.
/** 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.
* @return MODEACTION_ALLOW to allow the mode, or MODEACTION_DENY to prevent the mode, also see the description of 'parameter'.
*/
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding); /* Can change the mode parameter as its a ref */
+
/**
* If your mode is a listmode, then this method will be called for displaying an item list, e.g. on MODE \#channel +modechar
* without any parameter or other modes in the command.
*/
virtual void OnParameterMissing(User* user, User* dest, Channel* channel);
+ /** Called when a user attempts to set a mode and the parameter is invalid.
+ * @param user The user issuing the mode change
+ * @param targetchannel Either the channel target or NULL if changing a user mode.
+ * @param targetuser Either the user target or NULL if changing a channel mode.
+ * @param parameter The invalid parameter.
+ */
+ virtual void OnParameterInvalid(User* user, Channel* targetchannel, User* targetuser, const std::string& parameter);
+
+
/**
* If your mode is a listmode, this method will be called to display an empty list (just the end of list numeric)
* @param user The user issuing the command
- * @param channel The channel tehy're requesting an item list of (e.g. a banlist, or an exception list etc)
+ * @param channel The channel they're requesting an item list of (e.g. a banlist, or an exception list etc)
*/
virtual void DisplayEmptyList(User* user, Channel* channel);
/**
* When a MODETYPE_USER mode handler is being removed, the core will call this method for every user on the server.
- * The usermode will be removed using the appropiate server mode using InspIRCd::SendMode().
+ * The usermode will be removed using the appropriate server mode using InspIRCd::SendMode().
* @param user The user which the server wants to remove your mode from
*/
void RemoveMode(User* user);
* 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, irc::modestacker& stack);
+ virtual void RemoveMode(Channel* channel, Modes::ChangeList& changelist);
- inline unsigned int GetLevelRequired() const { return levelrequired; }
+ /** Retrieves the level required to modify this mode.
+ * @param adding Whether the mode is being added or removed.
+ */
+ inline unsigned int GetLevelRequired(bool adding) const
+ {
+ return adding ? ranktoset : ranktounset;
+ }
+
+ /** Retrieves the syntax of the parameter for this mode. */
+ const std::string& GetSyntax() const { return syntax; }
friend class ModeParser;
};
*/
unsigned int prefixrank;
+ /** Whether a client with this prefix can remove it from themself. */
+ bool selfremove;
+
public:
/**
* Constructor
*/
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.
* Finds the given member of the given channel, if it's not found an error message is sent to 'source'
* 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
class CoreExport SimpleUserModeHandler : public ModeHandler
{
public:
- SimpleUserModeHandler(Module* Creator, const std::string& Name, char modeletter)
- : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER) {}
- virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
+ SimpleUserModeHandler(Module* Creator, const std::string& Name, char modeletter, bool operonly = false)
+ : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER)
+ {
+ oper = operonly;
+ }
+
+ 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
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
public:
- SimpleChannelModeHandler(Module* Creator, const std::string& Name, char modeletter)
- : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
- virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
+ SimpleChannelModeHandler(Module* Creator, const std::string& Name, char modeletter, bool operonly = false)
+ : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL)
+ {
+ oper = operonly;
+ }
+
+ 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
class CoreExport ModeParser : public fakederef<ModeParser>
{
public:
+ /** The maximum number of modes which can be created. */
static const ModeHandler::Id MODEID_MAX = 64;
+ /** The maximum length of a mode parameter. */
+ static const size_t MODE_PARAM_MAX = 250;
+
/** 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 watcher classes
*/
- std::multimap<std::string, ModeWatcher*> modewatchermap;
+ ModeWatcherMap modewatchermap;
/** Last processed mode change
*/
Modes::ChangeList LastChangeList;
- /** 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.
- */
- void DisplayListModes(User* user, Channel* chan, const std::string& mode_sequence);
-
/**
* 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);
-
- /** Returns a list of user or channel mode characters.
- * Used for constructing the parts of the mode list in the 004 numeric.
- * @param mt Controls whether to list user modes or channel modes
- * @param needparam Return modes only if they require a parameter to be set
- * @return The available mode letters that satisfy the given conditions
- */
- std::string CreateModeList(ModeType mt, bool needparam = false);
-
- /** Recreate the cached mode list that is displayed in the 004 numeric
- * in Cached004ModeList.
- * Called when a mode handler is added or removed.
- */
- void RecreateModeListFor004Numeric();
+ ModeAction TryMode(User* user, User* targu, Channel* targc, Modes::Change& mcitem, bool SkipACL);
/** 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
*/
ModeHandler::Id AllocateModeId(ModeType mt);
- /** The string representing the last set of modes to be parsed.
- * Use GetLastParse() to get this value, to be used for display purposes.
- */
- std::string LastParse;
- std::vector<std::string> LastParseParams;
- std::vector<TranslateType> LastParseTranslate;
-
- unsigned int sent[256];
-
- unsigned int seq;
-
- /** Cached mode list for use in 004 numeric
- */
- std::string Cached004ModeList;
-
public:
typedef std::vector<ListModeBase*> ListModeList;
typedef std::vector<PrefixMode*> PrefixModeList;
*/
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.
*
* host.name -> *!*\@host.name
*
- * ident@host.name -> *!ident\@host.name
+ * ident\@host.name -> *!ident\@host.name
*
* 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.
* Throws a ModuleException if the mode cannot be added.
* @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.
/** Find the mode handler for a given mode and type.
* @param modeletter mode letter to search for
* @param mt type of mode to search for, user or channel
- * @returns a pointer to a ModeHandler class, or NULL of there isnt a handler for the given mode
+ * @returns a pointer to a ModeHandler class, or NULL of there isn't a handler for the given mode
*/
ModeHandler* FindMode(unsigned const char modeletter, ModeType mt);
*/
PrefixMode* FindPrefix(unsigned const char pfxletter);
- /** Returns a list of modes, space seperated by type:
- * 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();
-
- /** Generates a list of modes, comma seperated by type:
+ /** Generates a list of modes, comma separated by type:
* 1; Listmodes EXCEPT those with a prefix
* 2; Modes that take a param when adding or removing
* 3; Modes that only take a param when adding
* @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 PrefixMode* ModeHandler::IsPrefixMode()
{
- return Cached004ModeList;
+ return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : NULL);
}
-inline PrefixMode* ModeHandler::IsPrefixMode()
+inline const PrefixMode* ModeHandler::IsPrefixMode() const
{
- return (this->type_id == MC_PREFIX ? static_cast<PrefixMode*>(this) : NULL);
+ 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