#include "channels.h"
#include "ctables.h"
+class InspIRCd;
+
/**
* Holds the values for different type of modes
* that can exist, USER or CHANNEL type.
MASK_CHANNEL = 0 /* A channel mode */
};
+/**
+ * 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,
+ * and the parameter of the mode (or the parameter provided) in the std::string.
+ */
+typedef std::pair<bool,std::string> ModePair;
+
/** Each mode is implemented by ONE ModeHandler class.
* You must derive ModeHandler and add the child class to
* the list of modes handled by the ircd, using
class ModeHandler : public Extensible
{
protected:
+ InspIRCd* ServerInstance;
/**
* The mode letter you're implementing.
*/
* @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.
*/
- ModeHandler(char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly);
+ ModeHandler(InspIRCd* Instance, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly);
/**
* The default destructor does nothing
*/
/**
* If your mode needs special action during a server sync to determine which side wins when comparing timestamps,
* override this function and use it to return true or false. The default implementation just returns true if
- * theirs < ours.
+ * theirs < ours. This will only be called for non-listmodes with parameters, when adding the mode and where
+ * theirs == ours (therefore the default implementation will always return false).
* @param theirs The timestamp of the remote side
* @param ours The timestamp of the local side
* @param their_param Their parameter if the mode has a parameter
* @return True if the other side wins the merge, false if we win the merge for this mode.
*/
virtual bool CheckTimeStamp(time_t theirs, time_t ours, const std::string &their_param, const std::string &our_param, chanrec* channel);
+
+ /**
+ * When a remote server needs to bounce a set of modes, it will call this method for every mode
+ * in the mode string to determine if the mode is set or not.
+ * @param source of the mode change, this will be NULL for a server mode
+ * @param dest Target user of the mode change, if this is a user mode
+ * @param channel Target channel of the mode change, if this is a channel mode
+ * @param parameter The parameter given for the mode change, or an empty string
+ * @returns The first value of the pair should be true if the mode is set with the given parameter.
+ * In the case of permissions modes such as channelmode +o, this should return true if the user given
+ * as the parameter has the given privilage on the given channel. The string value of the pair will hold
+ * the current setting for this mode set locally, when the bool is true, or, the parameter given.
+ * This allows the local server to enforce our locally set parameters back to a remote server.
+ */
+ virtual ModePair ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter);
};
/**
class ModeWatcher : public Extensible
{
protected:
+ InspIRCd* ServerInstance;
/**
* The mode letter this class is watching
*/
/**
* The constructor initializes the mode and the mode type
*/
- ModeWatcher(char modeletter, ModeType type);
+ ModeWatcher(InspIRCd* Instance, char modeletter, ModeType type);
/**
* The default destructor does nothing.
*/
class ModeParser : public classbase
{
private:
+ InspIRCd* ServerInstance;
/**
* Mode handlers for each mode, to access a handler subtract
* 65 from the ascii value of the mode letter.
/**
* The constructor initializes all the RFC basic modes by using ModeParserAddMode().
*/
- ModeParser();
+ ModeParser(InspIRCd* Instance);
/**
* 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'.
*/
- static userrec* SanityChecks(userrec *user,const char *dest,chanrec *chan,int status);
+ userrec* SanityChecks(userrec *user,const char *dest,chanrec *chan,int status);
/**
* Grant a built in privilage (e.g. ops, halfops, voice) to a user on a channel
*/
- static const char* Grant(userrec *d,chanrec *chan,int MASK);
+ const char* Grant(userrec *d,chanrec *chan,int MASK);
/**
* Revoke a built in privilage (e.g. ops, halfops, voice) to a user on a channel
*/
- static const char* Revoke(userrec *d,chanrec *chan,int MASK);
+ const char* Revoke(userrec *d,chanrec *chan,int MASK);
/**
* Tidy a banmask. This makes a banmask 'acceptable' if fields are left out.
* E.g.
* and *user->server == NULL.
* @param servermode True if a server is setting the mode.
*/
- void Process(char **parameters, int pcnt, userrec *user, bool servermode);
+ void Process(const char** parameters, int pcnt, userrec *user, bool servermode);
+
+ /**
+ * Find the mode handler for a given mode and type
+ * @param modeletter mode letter to search for
+ * @param 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
+ */
+ ModeHandler* FindMode(unsigned const char modeletter, ModeType mt);
+
+ std::string UserModeList();
+
+ std::string ChannelModeList();
+
+ std::string ParaModeList();
+
+ bool InsertMode(std::string &output, const char* mode, unsigned short section);
};
/**
/**
* Standard constructor
*/
- cmd_mode () : command_t("MODE",0,1) { }
+ cmd_mode (InspIRCd* Instance) : command_t(Instance,"MODE",0,1) { syntax = "<target> <modes> {<mode-parameters>}"; }
/**
* Handle MODE
*/
- void Handle(char **parameters, int pcnt, userrec *user);
+ void Handle(const char** parameters, int pcnt, userrec *user);
};
#endif
projects / user / henk / code / inspircd.git / blobdiff