*/
enum DebugLevels { DEBUG, VERBOSE, DEFAULT, SPARSE, NONE };
-/** Used with OnExtendedMode() method of modules
- */
-enum ModeTargetType { MT_CHANNEL, MT_CLIENT, MT_SERVER };
-
/** Used with OnAccessCheck() method of modules
*/
enum AccessControlType {
TYPE_OTHER
};
+#include "globals.h"
#include "dynamic.h"
#include "base.h"
#include "ctables.h"
-#include "socket.h"
+#include "inspsocket.h"
#include <string>
#include <deque>
#include <sstream>
#include <typeinfo>
#include "timer.h"
+#include "mode.h"
class Server;
class ServerConfig;
+// Forward-delacare module for ModuleMessage etc
+class Module;
+
/** Low level definition of a FileReader classes file cache area
*/
typedef std::deque<std::string> file_cache;
typedef std::deque<userrec*> chanuserlist;
-// This #define allows us to call a method in all
-// loaded modules in a readable simple way, e.g.:
-// 'FOREACH_MOD OnConnect(user);'
+/** Holds a list of 'published features' for modules.
+ */
+typedef std::map<std::string,Module*> featurelist;
+/**
+ * This #define allows us to call a method in all
+ * loaded modules in a readable simple way, e.g.:
+ * 'FOREACH_MOD(I_OnXonnwxr,OnConnect(user));'
+ */
#define FOREACH_MOD(y,x) if (Config->global_implementation[y] > 0) { \
for (int _i = 0; _i <= MODCOUNT; _i++) { \
if (Config->implement_lists[_i][y]) \
} \
catch (ModuleException& modexcept) \
{ \
- log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
+ log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); \
} \
} \
}
-// This define is similar to the one above but returns a result in MOD_RESULT.
-// The first module to return a nonzero result is the value to be accepted,
-// and any modules after are ignored.
-
-// *********************************************************************************************
-
+/**
+ * This define is similar to the one above but returns a result in MOD_RESULT.
+ * The first module to return a nonzero result is the value to be accepted,
+ * and any modules after are ignored.
+ */
#define FOREACH_RESULT(y,x) { if (Config->global_implementation[y] > 0) { \
MOD_RESULT = 0; \
for (int _i = 0; _i <= MODCOUNT; _i++) { \
} \
} \
}
-
-// *********************************************************************************************
#define FD_MAGIC_NUMBER -42
// useful macros
-#define IS_LOCAL(x) (x->fd > -1)
+#define IS_LOCAL(x) ((x->fd > -1) && (x->fd <= MAX_DESCRIPTORS))
#define IS_REMOTE(x) (x->fd < 0)
#define IS_MODULE_CREATED(x) (x->fd == FD_MAGIC_NUMBER)
-/*extern void createcommand(char* cmd, handlerfunc f, char flags, int minparams, char* source);
-extern void server_mode(char **parameters, int pcnt, userrec *user);*/
-
-// class Version holds the version information of a Module, returned
-// by Module::GetVersion (thanks RD)
-
/** Holds a module's Version information
* The four members (set by the constructor only) indicate details as to the version number
* of a module. A class of type Version is returned by the GetVersion method of the Module class.
Admin(std::string name, std::string email, std::string nick);
};
-
-// Forward-delacare module for ModuleMessage etc
-class Module;
-
-// Thanks to Rob (from anope) for the idea of this message passing API
-// (its been done before, but this seemed a very neat and tidy way...
-
/** The ModuleMessage class is the base class of Request and Event
* This class is used to represent a basic data structure which is passed
* between modules for safe inter-module communications.
char* Send();
};
-/** Holds an extended mode's details.
- * Used internally by modules.cpp
- */
-class ExtMode : public classbase
-{
- public:
- char modechar;
- int type;
- bool needsoper;
- int params_when_on;
- int params_when_off;
- bool list;
- ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off), list(false) { };
-};
-
-
/** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
* When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
* a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
* be loaded. If this happens, the error message returned by ModuleException::GetReason will be displayed to the user
* attempting to load the module, or dumped to the console if the ircd is currently loading for the first time.
*/
-class ModuleException
+class ModuleException : public classbase
{
private:
/** Holds the error message to be displayed
/** Implementation-specific flags which may be set in Module::Implements()
*/
enum Implementation { I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash, I_OnServerRaw,
- I_OnExtendedMode, I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois, I_OnUserPreInvite,
+ I_OnUserPreJoin, I_OnUserPreKick, I_OnUserKick, I_OnOper, I_OnInfo, I_OnWhois, I_OnUserPreInvite,
I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNotice, I_OnUserPreNick, I_OnUserMessage, I_OnUserNotice, I_OnMode,
I_OnGetServerDescription, I_OnSyncUser, I_OnSyncChannel, I_OnSyncChannelMetaData, I_OnSyncUserMetaData,
I_OnDecodeMetaData, I_ProtoSendMode, I_ProtoSendMetaData, I_OnWallops, I_OnChangeHost, I_OnChangeName, I_OnAddGLine,
I_OnAddZLine, I_OnAddQLine, I_OnAddKLine, I_OnAddELine, I_OnDelGLine, I_OnDelZLine, I_OnDelKLine, I_OnDelELine, I_OnDelQLine,
I_OnCleanup, I_OnUserPostNick, I_OnAccessCheck, I_On005Numeric, I_OnKill, I_OnRemoteKill, I_OnLoadModule, I_OnUnloadModule,
- I_OnBackgroundTimer, I_OnSendList, I_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, I_OnRawMode, I_OnCheckInvite,
+ I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, I_OnRawMode, I_OnCheckInvite,
I_OnCheckKey, I_OnCheckLimit, I_OnCheckBan, I_OnStats, I_OnChangeLocalUserHost, I_OnChangeLocalUserGecos, I_OnLocalTopicChange,
I_OnPostLocalTopicChange, I_OnEvent, I_OnRequest, I_OnOperCompre, I_OnGlobalOper, I_OnGlobalConnect, I_OnAddBan, I_OnDelBan,
I_OnRawSocketAccept, I_OnRawSocketClose, I_OnRawSocketWrite, I_OnRawSocketRead, I_OnChangeLocalUserGECOS, I_OnUserRegister,
/** Base class for all InspIRCd modules
* This class is the base class for InspIRCd modules. All modules must inherit from this class,
* its methods will be called when irc server events occur. class inherited from module must be
- * instantiated by the ModuleFactory class (see relevent section) for the plugin to be initialised.
+ * instantiated by the ModuleFactory class (see relevent section) for the module to be initialised.
*/
-class Module : public classbase
+class Module : public Extensible
{
public:
*/
virtual void OnServerRaw(std::string &raw, bool inbound, userrec* user);
- /** Called whenever an extended mode is to be processed.
- * The type parameter is MT_SERVER, MT_CLIENT or MT_CHANNEL, dependent on where the mode is being
- * changed. mode_on is set when the mode is being set, in which case params contains a list of
- * parameters for the mode as strings. If mode_on is false, the mode is being removed, and parameters
- * may contain the parameters for the mode, dependent on wether they were defined when a mode handler
- * was set up with Server::AddExtendedMode
- * If the mode is a channel mode, target is a chanrec*, and if it is a user mode, target is a userrec*.
- * You must cast this value yourself to make use of it.
- * @param user The user issuing the mode
- * @param target The user or channel having the mode set on them
- * @param modechar The mode character being set
- * @param type The type of mode (user or channel) being set
- * @param mode_on True if the mode is being set, false if it is being unset
- * @param params A list of parameters for any channel mode (currently supports either 0 or 1 parameters)
- */
- virtual int OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms);
-
/** Called whenever a user is about to join a channel, before any processing is done.
* Returning a value of 1 from this function stops the process immediately, causing no
* output to be sent to the user by the core. If you do this you must produce your own numerics,
* AC_DEVOICE (4) - a user is being devoiced<br>
* AC_HALFOP (5) - a user is being halfopped<br>
* AC_DEHALFOP (6) - a user is being dehalfopped<br>
- * AC_INVITE (7) - a user is being invited<br>
+ * AC_INVITE () - a user is being invited<br>
* AC_GENERAL_MODE (8) - a user channel mode is being changed<br><br>
* Upon returning from your function you must return either ACR_DEFAULT, to indicate the module wishes
* to do nothing, or ACR_DENY where approprate to deny the action, and ACR_ALLOW where appropriate to allow
*/
virtual void OnBackgroundTimer(time_t curtime);
- /** Called whenever a list is needed for a listmode.
- * For example, when a /MODE #channel +b (without any other parameters) is called,
- * if a module was handling +b this function would be called. The function can then
- * output any lists it wishes to. Please note that all modules will see all mode
- * characters to provide the ability to extend each other, so please only output
- * a list if the mode character given matches the one(s) you want to handle.
- * @param user The user requesting the list
- * @param channel The channel the list is for
- * @param mode The listmode which a list is being requested on
- */
- virtual void OnSendList(userrec* user, chanrec* channel, char mode);
-
/** Called whenever any command is about to be executed.
* This event occurs for all registered commands, wether they are registered in the core,
* or another module, but it will not occur for invalid commands (e.g. ones which do not
*/
virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult);
+ /** Called whenever a user sets away.
+ * This method has no parameter for the away message, as it is available in the
+ * user record as userrec::awaymsg.
+ */
virtual void OnSetAway(userrec* user);
+ /** Called when a user cancels their away state.
+ */
virtual void OnCancelAway(userrec* user);
};
* output to users and other servers. All modules should instantiate at least one copy of this class,
* and use its member functions to perform their tasks.
*/
-class Server : public classbase
+class Server : public Extensible
{
public:
/** Default constructor.
*/
std::string GetVersion();
+ /** Publish a 'feature'.
+ * There are two ways for a module to find another module it depends on.
+ * Either by name, using Server::FindModule, or by feature, using this
+ * function. A feature is an arbitary string which identifies something this
+ * module can do. For example, if your module provides SSL support, but other
+ * modules provide SSL support too, all the modules supporting SSL should
+ * publish an identical 'SSL' feature. This way, any module requiring use
+ * of SSL functions can just look up the 'SSL' feature using FindFeature,
+ * then use the module pointer they are given.
+ * @param FeatureName The case sensitive feature name to make available
+ * @param Mod a pointer to your module class
+ * @returns True on success, false if the feature is already published by
+ * another module.
+ */
+ bool PublishFeature(const std::string &FeatureName, Module* Mod);
+
+ /** Unpublish a 'feature'.
+ * When your module exits, it must call this method for every feature it
+ * is providing so that the feature table is cleaned up.
+ * @param FeatureName the feature to remove
+ */
+ bool UnpublishFeature(const std::string &FeatureName);
+
+ /** Find a 'feature'.
+ * There are two ways for a module to find another module it depends on.
+ * Either by name, using Server::FindModule, or by feature, using the
+ * Server::PublishFeature method. A feature is an arbitary string which
+ * identifies something this module can do. For example, if your module
+ * provides SSL support, but other modules provide SSL support too, all
+ * the modules supporting SSL should publish an identical 'SSL' feature.
+ * To find a module capable of providing the feature you want, simply
+ * call this method with the feature name you are looking for.
+ * @param FeatureName The feature name you wish to obtain the module for
+ * @returns A pointer to a valid module class on success, NULL on failure.
+ */
+ Module* FindFeature(const std::string &FeatureName);
+
+ const std::string& GetModuleName(Module* m);
+
/** Writes a log string.
* This method writes a line of text to the log. If the level given is lower than the
* level given in the configuration, this command has no effect.
* back to the user from which it originated, as seen in NICK (see RFC 1459). Otherwise, it
* is only sent to the other recipients, as seen in QUIT.
*/
- virtual void SendCommon(userrec* User, std::string text, bool IncludeSender);
+ virtual void SendCommon(userrec* User, const std::string &text, bool IncludeSender);
/** Sends a WALLOPS message.
* This method writes a WALLOPS message to all users with the +w flag, originating from the
*/
virtual Admin GetAdmin();
- /** Adds an extended mode letter which is parsed by a module.
- * This allows modules to add extra mode letters, e.g. +x for hostcloak.
- * the "type" parameter is either MT_CHANNEL, MT_CLIENT, or MT_SERVER, to
- * indicate wether the mode is a channel mode, a client mode, or a server mode.
- * requires_oper is used with MT_CLIENT type modes only to indicate the mode can only
- * be set or unset by an oper. If this is used for MT_CHANNEL type modes it is ignored.
- * params_when_on is the number of modes to expect when the mode is turned on
- * (for type MT_CHANNEL only), e.g. with mode +k, this would have a value of 1.
- * the params_when_off value has a similar value to params_when_on, except it indicates
- * the number of parameters to expect when the mode is disabled. Modes which act in a similar
- * way to channel mode +l (e.g. require a parameter to enable, but not to disable) should
- * use this parameter. The function returns false if the mode is unavailable, and will not
- * attempt to allocate another character, as this will confuse users. This also means that
- * as only one module can claim a specific mode character, the core does not need to keep track
- * of which modules own which modes, which speeds up operation of the server. In this version,
- * a mode can have at most one parameter, attempting to use more parameters will have undefined
- * effects.
- */
- virtual bool AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off);
-
- /** Adds an extended mode letter which is parsed by a module and handled in a list fashion.
- * This call is used to implement modes like +q and +a. The characteristics of these modes are
- * as follows:
- *
- * (1) They are ALWAYS on channels, not on users, therefore their type is MT_CHANNEL
- *
- * (2) They always take exactly one parameter when being added or removed
- *
- * (3) They can be set multiple times, usually on users in channels
- *
- * (4) The mode and its parameter are NOT stored in the channels modes structure
- *
- * It is down to the module handling the mode to maintain state and determine what 'items' (e.g. users,
- * or a banlist) have the mode set on them, and process the modes at the correct times, e.g. during access
- * checks on channels, etc. When the extended mode is triggered the OnExtendedMode method will be triggered
- * as above. Note that the target you are given will be a channel, if for example your mode is set 'on a user'
- * (in for example +a) you must use Server::Find to locate the user the mode is operating on.
- * Your mode handler may return 1 to handle the mode AND tell the core to display the mode change, e.g.
- * '+aaa one two three' in the case of the mode for 'two', or it may return -1 to 'eat' the mode change,
- * so the above example would become '+aa one three' after processing.
- */
- virtual bool AddExtendedListMode(char modechar);
+ virtual bool AddMode(ModeHandler* mh, const unsigned char modechar);
+
+ virtual bool AddModeWatcher(ModeWatcher* mw);
+
+ virtual bool DelModeWatcher(ModeWatcher* mw);
/** Adds a command to the command table.
* This allows modules to add extra commands into the command table. You must place a function within your
* dhost member of userrec, as any change applied via this method will be propogated to any
* linked servers.
*/
- virtual void ChangeHost(userrec* user, std::string host);
+ virtual void ChangeHost(userrec* user, const std::string &host);
/** Change GECOS (fullname) of a user.
* You should always call this method to change a user's GECOS rather than writing directly to the
* fullname member of userrec, as any change applied via this method will be propogated to any
* linked servers.
*/
- virtual void ChangeGECOS(userrec* user, std::string gecos);
+ virtual void ChangeGECOS(userrec* user, const std::string &gecos);
/** Returns true if the servername you give is ulined.
* ULined servers have extra privilages. They are allowed to change nicknames on remote servers,
* to indicate who or what sent the data, usually this is the nickname of a person, or a server
* name.
*/
- virtual void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string nickname);
+ virtual void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname);
/** Adds a Z-line
* The Z-line is propogated to all of the servers in the mesh and enforced as soon as it is added.
*/
virtual void DelSocket(InspSocket* sock);
+ /** Causes the local server to rehash immediately.
+ * WARNING: Do not call this method from within your rehash method, for
+ * obvious reasons!
+ */
virtual void RehashServer();
+ /** This method returns the total number of channels on the network.
+ */
virtual long GetChannelCount();
+ /** This method returns a channel whos index is greater than or equal to 0 and less than the number returned by Server::GetChannelCount().
+ * This is slower (by factors of dozens) than requesting a channel by name with Server::FindChannel(), however there are times when
+ * you wish to safely iterate the channel list, saving your position, with large amounts of time in between, which is what this function
+ * is useful for.
+ */
virtual chanrec* GetChannelIndex(long index);
- void DumpText(userrec* User, std::string LinePrefix, stringstream &TextStream);
+ /** Dumps text (in a stringstream) to a user. The stringstream should not contain linefeeds, as it will be split
+ * automatically by the function into safe amounts. The line prefix given is prepended onto each line (e.g. a servername
+ * and a numeric).
+ */
+ void DumpText(userrec* User, const std::string &LinePrefix, stringstream &TextStream);
};
* core is changed). It will contain a pointer to the configuration file data with unneeded data
* (such as comments) stripped from it.
*/
- std::stringstream *cache;
- std::stringstream *errorlog;
+ ConfigDataHash* data;
+ std::ostringstream* errorlog;;
/** Used to store errors
*/
+ bool privatehash; // If we're using our own config data hash or not.
bool readerror;
long error;
*/
class FileReader : public classbase
{
+ /** The file contents
+ */
file_cache fc;
public:
/** Default constructor.
typedef DLLFactory<ModuleFactory> ircd_module;
-
-bool ModeDefined(char c, int i);
-bool ModeDefinedOper(char c, int i);
-int ModeDefinedOn(char c, int i);
-int ModeDefinedOff(char c, int i);
-void ModeMakeList(char modechar);
-bool ModeIsListMode(char modechar, int type);
+typedef std::vector<Module*> ModuleList;
+typedef std::vector<ircd_module*> FactoryList;
#endif