X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fmode.h;h=81858a823897496ddf1c2cb968003f50a9da6e70;hb=67a4a9b62355ea57a2f4521ca5fc53bd4eac3a1f;hp=a6b10475deed9747ab848a0ef91f8c105e913a13;hpb=3d8ec5dbd9cfde34fcbc63ad7b9b1369866f0a33;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/mode.h b/include/mode.h index a6b10475d..81858a823 100644 --- a/include/mode.h +++ b/include/mode.h @@ -70,6 +70,16 @@ enum PrefixModeValue OP_VALUE = 30000 }; +enum ParamSpec +{ + /** No parameters */ + PARAM_NONE, + /** Parameter required on mode setting only */ + PARAM_SETONLY, + /** Parameter always required */ + PARAM_ALWAYS +}; + /** * Used by ModeHandler::ModeSet() to return the state of a mode upon a channel or user. * The pair contains an activity flag, true if the mode is set with the given parameter, @@ -95,21 +105,29 @@ class CoreExport ModeHandler : public classbase { protected: /** - * Creator/owner pointer + * The mode parameter translation type + */ + TranslateType m_paramtype; + + /** What kind of parameters does the mode take? */ - InspIRCd* ServerInstance; + ParamSpec parameters_taken; + /** * The mode letter you're implementing. */ - char mode; - /** - * Number of parameters when being set + const char mode; + + /** Mode prefix, or 0 */ - int n_params_on; + char prefix; + /** - * Number of parameters when being unset + * True if the mode requires oper status + * to set. */ - int n_params_off; + bool oper; + /** * Mode is a 'list' mode. The behaviour * of your mode is now set entirely within @@ -121,24 +139,12 @@ class CoreExport ModeHandler : public classbase * (e.g. banlists, etc) */ bool list; + /** * The mode type, either MODETYPE_USER or * MODETYPE_CHANNEL. */ ModeType m_type; - /** - * The mode parameter translation type - */ - TranslateType m_paramtype; - /** - * True if the mode requires oper status - * to set. - */ - bool oper; - - /** Mode prefix, or 0 - */ - char prefix; /** Number of items with this mode set on them */ @@ -147,36 +153,26 @@ class CoreExport ModeHandler : public classbase /** The prefix char needed on channel to use this mode, * only checked for channel modes */ - char prefixneeded; + int levelrequired; public: /** Module that created this mode. NULL for core modes */ - Module* creator; + Module* const creator; + /** Long-form name + */ + const std::string name; /** * The constructor for ModeHandler initalizes the mode handler. * The constructor of any class you derive from ModeHandler should * probably call this constructor with the parameters set correctly. + * @param name A one-word name for the mode * @param modeletter The mode letter you wish to handle - * @param parameters_on The number of parameters your mode takes when being set. Note that any nonzero value is treated as 1. - * @param parameters_off The number of parameters your mode takes when being unset. Note that any nonzero value is treated as 1. - * @param listmode Set to true if your mode is a listmode, e.g. it will respond to MODE #channel +modechar with a list of items - * @param ModeType Set this to MODETYPE_USER for a usermode, or MODETYPE_CHANNEL for a channelmode. - * @param operonly Set this to true if only opers should be allowed to set or unset the mode. - * @param mprefix For listmodes where parameters are NICKNAMES which are on the channel (for example, +ohv), you may define a prefix. - * When you define a prefix, it can be returned in NAMES, WHO etc if it has the highest value (as returned by GetPrefixRank()) - * In the core, the only modes to implement prefixes are +ovh (ops, voice, halfop) which define the prefix characters @, % and + - * and the rank values OP_VALUE, HALFOP_VALUE and VOICE_VALUE respectively. Any prefixes you define should have unique values proportional - * to these three defaults or proportional to another mode in a module you depend on. See src/cmode_o.cpp as an example. - * @param prefixrequired The prefix required to change this mode - * @param translate The translation type for the argument(s) of this mode - */ - ModeHandler(InspIRCd* Instance, Module* me, char modeletter, int parameters_on, int parameters_off, - bool listmode, ModeType type, bool operonly, char mprefix = 0, - char prefixrequired = '%', TranslateType translate = TR_TEXT); - /** - * The default destructor does nothing + * @param params Parameters taken by the mode + * @param type Type of the mode (MODETYPE_USER or MODETYPE_CHANNEL) */ + ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type); + virtual bool cull(); virtual ~ModeHandler(); /** * Returns true if the mode is a list mode @@ -187,7 +183,7 @@ class CoreExport ModeHandler : public classbase * also implement GetPrefixRank() to return an integer * value for this mode prefix. */ - char GetPrefix(); + inline char GetPrefix() const { return prefix; } /** Get number of items with this mode set on them */ virtual unsigned int GetCount(); @@ -205,15 +201,15 @@ class CoreExport ModeHandler : public classbase /** * Returns the mode's type */ - ModeType GetModeType(); + inline ModeType GetModeType() const { return m_type; } /** * Returns the mode's parameter translation type */ - TranslateType GetTranslateType(); + inline TranslateType GetTranslateType() const { return m_paramtype; } /** * Returns true if the mode can only be set/unset by an oper */ - bool NeedsOper(); + 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. @@ -231,6 +227,16 @@ class CoreExport ModeHandler : public classbase */ virtual std::string GetUserParameter(User* useor); + /** + * 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 + */ + virtual ModResult AccessCheck(User* source, Channel* channel, std::string ¶meter, bool adding); + /** * Called when a mode change for your mode occurs. * @param source Contains the user setting the mode. @@ -277,7 +283,7 @@ class CoreExport ModeHandler : public classbase * @param channel The channel we are checking against * @return True if the other side wins the merge, false if we win the merge for this mode. */ - virtual bool CheckTimeStamp(std::string &their_param, const std::string &our_param, Channel* channel); + virtual bool ResolveModeConflict(std::string &their_param, const std::string &our_param, Channel* channel); /** * When a remote server needs to bounce a set of modes, it will call this method for every mode @@ -314,9 +320,7 @@ class CoreExport ModeHandler : public classbase */ virtual void RemoveMode(Channel* channel, irc::modestacker* stack = NULL); - char GetNeededPrefix(); - - void SetNeededPrefix(char needsprefix); + inline unsigned int GetLevelRequired() const { return levelrequired; } }; /** A prebuilt mode handler which handles a simple user mode, e.g. no parameters, usable by any user, with no extra @@ -327,8 +331,8 @@ class CoreExport ModeHandler : public classbase class CoreExport SimpleUserModeHandler : public ModeHandler { public: - SimpleUserModeHandler(InspIRCd* Instance, Module* Creator, char modeletter) - : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_USER, false) {} + 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); }; @@ -341,8 +345,8 @@ class CoreExport SimpleUserModeHandler : public ModeHandler class CoreExport SimpleChannelModeHandler : public ModeHandler { public: - SimpleChannelModeHandler(InspIRCd* Instance, Module* Creator, char modeletter) - : ModeHandler(Instance, Creator, modeletter, 0, 0, false, MODETYPE_CHANNEL, false) {} + 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); }; @@ -356,10 +360,6 @@ class CoreExport SimpleChannelModeHandler : public ModeHandler class CoreExport ModeWatcher : public classbase { protected: - /** - * Creator/owner pointer - */ - InspIRCd* ServerInstance; /** * The mode letter this class is watching */ @@ -370,10 +370,11 @@ class CoreExport ModeWatcher : public classbase ModeType m_type; public: + Module* const creator; /** * The constructor initializes the mode and the mode type */ - ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type); + ModeWatcher(Module* creator, char modeletter, ModeType type); /** * The default destructor does nothing. */ @@ -427,10 +428,6 @@ typedef std::vector::iterator ModeWatchIter; class CoreExport ModeParser : public classbase { private: - /** - * Creator/owner pointer - */ - InspIRCd* ServerInstance; /** 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 @@ -471,19 +468,13 @@ class CoreExport ModeParser : public classbase /** The constructor initializes all the RFC basic modes by using ModeParserAddMode(). */ - ModeParser(InspIRCd* Instance); + ModeParser(); ~ModeParser(); /** Used to check if user 'd' should be allowed to do operation 'MASK' on channel 'chan'. * for example, should 'user A' be able to 'op' on 'channel B'. */ User* SanityChecks(User *user,const char *dest,Channel *chan,int status); - /** Grant a built in privilage (e.g. ops, halfops, voice) to a user on a channel - */ - const char* Grant(User *d,Channel *chan,int MASK); - /** Revoke a built in privilage (e.g. ops, halfops, voice) to a user on a channel - */ - const char* Revoke(User *d,Channel *chan,int MASK); /** Tidy a banmask. This makes a banmask 'acceptable' if fields are left out. * E.g. * @@ -519,6 +510,7 @@ class CoreExport ModeParser : public classbase * @return True if the mode was successfully removed. */ bool DelMode(ModeHandler* mh); + /** Add a mode watcher. * A mode watcher is triggered before and after a mode handler is * triggered. See the documentation of class ModeWatcher for more @@ -581,9 +573,7 @@ class CoreExport ModeParser : public classbase */ std::string GiveModeList(ModeMasks m); - /** Used by this class internally during std::sort and 005 generation - */ - static bool PrefixComparison(prefixtype one, prefixtype two); + static bool PrefixComparison(ModeHandler* one, ModeHandler* two); /** This returns the PREFIX=(ohv)@%+ section of the 005 numeric. */