#ifndef __MODE_H
#define __MODE_H
-// include the common header files
-
+/* include the common header files */
#include <typeinfo>
#include <iostream>
#include <string>
#include "channels.h"
#include "ctables.h"
-/**
- * This enum contains a set of bitmasks which
- * are used to compress the 'standard' usermodes
- * +isw into a bitfield for fast checking.
- */
-enum UserModeBits {
- UM_INVISIBLE = 1,
- UM_SERVERNOTICE = 2,
- UM_WALLOPS = 4
-};
-
/**
* 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
* mode is expected to have a parameter, then this is
* equivalent to returning MODEACTION_DENY.
*/
-class ModeHandler
+class ModeHandler : public Extensible
{
+ protected:
/**
* The mode letter you're implementing.
*/
/**
* 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
+/**
+ * The ModeWatcher class can be used to alter the behaviour of a mode implemented
+ * by the core or by another module. To use ModeWatcher, derive a class from it,
+ * and attach it to the mode using Server::AddModeWatcher and Server::DelModeWatcher.
+ * A ModeWatcher will be called both before and after the mode change.
+ */
+class ModeWatcher : public Extensible
{
+ protected:
+ /**
+ * The mode letter this class is watching
+ */
char mode;
+ /**
+ * The mode type being watched (user or channel)
+ */
ModeType m_type;
public:
+ /**
+ * The constructor initializes the mode and the mode type
+ */
ModeWatcher(char modeletter, ModeType type);
+ /**
+ * The default destructor does nothing.
+ */
virtual ~ModeWatcher();
+ /**
+ * Get the mode character being watched
+ * @return The mode character being watched
+ */
char GetModeChar();
+ /**
+ * Get the mode type being watched
+ * @return The mode type being watched (user or channel)
+ */
ModeType GetModeType();
- virtual bool BeforeMode(userrec* source, userrec* dest, chanrec* channel, std::string ¶meter, bool adding, ModeType type); /* Can change the mode parameter */
+ /**
+ * Before the mode character is processed by its handler, this method will be called.
+ * @param source The sender of the mode
+ * @param dest The target user for the mode, if you are watching a user mode
+ * @param channel The target channel for the mode, if you are watching a channel mode
+ * @param parameter The parameter of the mode, if the mode is supposed to have a parameter.
+ * If you alter the parameter you are given, the mode handler will see your atered version
+ * when it handles the mode.
+ * @param adding True if the mode is being added and false if it is being removed
+ * @type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
+ * @return True to allow the mode change to go ahead, false to abort it. If you abort the
+ * change, the mode handler (and ModeWatcher::AfterMode()) will never see the mode change.
+ */
+ virtual bool BeforeMode(userrec* source, userrec* dest, chanrec* channel, std::string ¶meter, bool adding, ModeType type);
+ /**
+ * After the mode character has been processed by the ModeHandler, this method will be called.
+ * @param source The sender of the mode
+ * @param dest The target user for the mode, if you are watching a user mode
+ * @param channel The target channel for the mode, if you are watching a channel mode
+ * @param parameter The parameter of the mode, if the mode is supposed to have a parameter.
+ * You cannot alter the parameter here, as the mode handler has already processed it.
+ * @param adding True if the mode is being added and false if it is being removed
+ * @type The mode type, either MODETYPE_USER or MODETYPE_CHANNEL
+ */
virtual void AfterMode(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter, bool adding, ModeType type);
};
typedef std::vector<ModeWatcher*>::iterator ModeWatchIter;
-class ModeParser
+class ModeParser : public classbase
{
private:
/**
* we have 256 lists of them.
*/
std::vector<ModeWatcher*> modewatchers[256];
-
- char* GiveOps(userrec *user,char *dest,chanrec *chan,int status);
- char* GiveHops(userrec *user,char *dest,chanrec *chan,int status);
- char* GiveVoice(userrec *user,char *dest,chanrec *chan,int status);
- char* TakeOps(userrec *user,char *dest,chanrec *chan,int status);
- char* TakeHops(userrec *user,char *dest,chanrec *chan,int status);
- char* TakeVoice(userrec *user,char *dest,chanrec *chan,int status);
- userrec* SanityChecks(userrec *user,char *dest,chanrec *chan,int status);
- char* Grant(userrec *d,chanrec *chan,int MASK);
- char* Revoke(userrec *d,chanrec *chan,int MASK);
+ /**
+ * Displays the current modes of a channel or user.
+ * Used by ModeParser::Process.
+ */
+ void DisplayCurrentModes(userrec *user, userrec* targetuser, chanrec* targetchannel, const char* text);
+
public:
+
+ /**
+ * The constructor initializes all the RFC basic modes by using ModeParserAddMode().
+ */
ModeParser();
- bool AddMode(ModeHandler* mh, unsigned const char modeletter);
- void Process(char **parameters, int pcnt, userrec *user, bool servermode);
+
+ /**
+ * 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);
+ /**
+ * 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);
+ /**
+ * 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);
+ /**
+ * Tidy a banmask. This makes a banmask 'acceptable' if fields are left out.
+ * E.g.
+ *
+ * nick -> nick!*@*
+ *
+ * nick!ident -> nick!ident@*
+ *
+ * host.name -> *!*@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);
+ /**
+ * Add a mode to the mode parser. The modeletter parameter
+ * is purely to save on doing a lookup in the function, as
+ * strictly it could be obtained via ModeHandler::GetModeChar().
+ * @return True if the mode was successfully added.
+ */
+ bool AddMode(ModeHandler* mh, unsigned const char modeletter);
+ /**
+ * 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
+ * information.
+ * @param mw The ModeWatcher you want to add
+ * @return True if the ModeWatcher was added correctly
+ */
+ bool AddModeWatcher(ModeWatcher* mw);
+ /**
+ * Delete a mode watcher.
+ * A mode watcher is triggered before and after a mode handler is
+ * triggered. See the documentation of class ModeWatcher for more
+ * information.
+ * @param mw The ModeWatcher you want to delete
+ * @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.
+ * @param pcnt The number of items in the parameters array
+ * @param user The user setting or removing the modes. When the modes are set
+ * by a server, an 'uninitialized' userrec is used, where *user::nick == NULL
+ * and *user->server == NULL.
+ * @param servermode True if a server is setting the mode.
+ */
+ 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();
};
+/**
+ * Command handler class for the MODE command.
+ * put here for completeness.
+ */
class cmd_mode : public command_t
{
public:
- cmd_mode () : command_t("MODE",0,1) { }
- void Handle(char **parameters, int pcnt, userrec *user);
+ /**
+ * Standard constructor
+ */
+ cmd_mode () : command_t("MODE",0,1) { syntax = "<target> <modes> {<mode-parameters>}"; }
+ /**
+ * Handle MODE
+ */
+ void Handle(const char** parameters, int pcnt, userrec *user);
};
#endif