X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fmode.h;h=ccbfe6f28b6ff93af0682db98e7ad05a4853a14a;hb=384ef31bc01e4a1a2e59d082c9066002410ba54a;hp=64829845f805c503979f912901c241b9a6d242de;hpb=19f0c09aa783cc3b945c880d509c1da8bc8e0275;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/mode.h b/include/mode.h index 64829845f..ccbfe6f28 100644 --- a/include/mode.h +++ b/include/mode.h @@ -148,10 +148,11 @@ class CoreExport ModeHandler : public ServiceProvider */ 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: /** @@ -166,7 +167,7 @@ class CoreExport ModeHandler : public ServiceProvider * @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 @@ -184,6 +185,12 @@ class CoreExport ModeHandler : public ServiceProvider */ 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 @@ -192,10 +199,22 @@ class CoreExport ModeHandler : public ServiceProvider /** * 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(); + /** + * 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 */ @@ -214,7 +233,7 @@ class CoreExport ModeHandler : public ServiceProvider * 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. @@ -223,7 +242,7 @@ class CoreExport ModeHandler : public ServiceProvider /** 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. @@ -302,7 +321,13 @@ class CoreExport ModeHandler : public ServiceProvider */ 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; + } friend class ModeParser; }; @@ -334,6 +359,9 @@ class CoreExport PrefixMode : public ModeHandler */ unsigned int prefixrank; + /** Whether a client with this prefix can remove it from themself. */ + bool selfremove; + public: /** * Constructor @@ -345,6 +373,16 @@ class CoreExport PrefixMode : public ModeHandler */ 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' @@ -358,14 +396,29 @@ class CoreExport PrefixMode : public ModeHandler * 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 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* channel, Modes::ChangeList& changelist); + 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 @@ -394,7 +447,7 @@ 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); + 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 @@ -407,7 +460,7 @@ 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); + ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE; }; /** @@ -450,7 +503,7 @@ class CoreExport ModeWatcher : public classbase * 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. @@ -568,7 +621,7 @@ class CoreExport ModeParser : public fakederef /** Cached mode list for use in 004 numeric */ - std::string Cached004ModeList; + TR1NS::array Cached004ModeList; public: typedef std::vector ListModeList; @@ -598,7 +651,7 @@ class CoreExport ModeParser : public fakederef /** 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::levelrequired and ModeHandler::AccessCheck(). + * 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. */ @@ -608,9 +661,7 @@ class CoreExport ModeParser : public fakederef 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. @@ -735,13 +786,13 @@ class CoreExport ModeParser : public fakederef */ 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& GetModeListFor004Numeric(); /** Generates a list of modes, comma seperated by type: * 1; Listmodes EXCEPT those with a prefix @@ -780,7 +831,7 @@ class CoreExport ModeParser : public fakederef void ShowListModeList(User* user, Channel* chan, ModeHandler* mh); }; -inline const std::string& ModeParser::GetModeListFor004Numeric() +inline const TR1NS::array& ModeParser::GetModeListFor004Numeric() { return Cached004ModeList; } @@ -790,12 +841,27 @@ inline PrefixMode* ModeHandler::IsPrefixMode() return (this->type_id == MC_PREFIX ? static_cast(this) : NULL); } +inline const PrefixMode* ModeHandler::IsPrefixMode() const +{ + return (this->type_id == MC_PREFIX ? static_cast(this) : NULL); +} + inline ListModeBase* ModeHandler::IsListModeBase() { return (this->type_id == MC_LIST ? reinterpret_cast(this) : NULL); } +inline const ListModeBase* ModeHandler::IsListModeBase() const +{ + return (this->type_id == MC_LIST ? reinterpret_cast(this) : NULL); +} + inline ParamModeBase* ModeHandler::IsParameterMode() { return (this->type_id == MC_PARAM ? reinterpret_cast(this) : NULL); } + +inline const ParamModeBase* ModeHandler::IsParameterMode() const +{ + return (this->type_id == MC_PARAM ? reinterpret_cast(this) : NULL); +}