X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fmodules.h;h=51eb5a19baaba9f8affcf6bb1e0e5918adca4a13;hb=3759fe0ba2420bd564abb4b034582ea0866907aa;hp=8baf31b4c498a6f47a39a659a57ab7520e9e39b4;hpb=e91d5023f3ace4bb80d197621d6dc20b6e293641;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/modules.h b/include/modules.h index 8baf31b4c..51eb5a19b 100644 --- a/include/modules.h +++ b/include/modules.h @@ -2,19 +2,15 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * - * - * Written by Craig Edwards, Craig McLure, and others. + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * * This program is free but copyrighted software; see - * the file COPYING for details. + * the file COPYING for details. * * --------------------------------------------------- */ - #ifndef __MODULES_H #define __MODULES_H @@ -56,6 +52,11 @@ enum TargetTypeFlags { TYPE_OTHER }; +enum MessageType { + MSG_PRIVMSG = 0, + MSG_NOTICE = 1 +}; + #include "globals.h" #include "dynamic.h" #include "base.h" @@ -64,15 +65,27 @@ enum TargetTypeFlags { #include #include #include -#include #include "timer.h" #include "mode.h" #include "dns.h" -class Server; +/** If you change the module API, change this value. + * If you have enabled ipv6, the sizes of structs is + * different, and modules will be incompatible with + * ipv4 servers, so this value will be ten times as + * high on ipv6 servers. + */ +#define NATIVE_API_VERSION 11021 +#ifdef IPV6 +#define API_VERSION (NATIVE_API_VERSION * 10) +#else +#define API_VERSION (NATIVE_API_VERSION * 1) +#endif + class ServerConfig; -// Forward-delacare module for ModuleMessage etc +/* Forward-delacare module for ModuleMessage etc + */ class Module; /** Low level definition of a FileReader classes file cache area @@ -84,35 +97,43 @@ typedef file_cache string_list; */ typedef std::map featurelist; +/** Holds a list of modules which implement an interface + */ +typedef std::deque modulelist; + +/** Holds a list of all modules which implement interfaces, by interface name + */ +typedef std::map > interfacelist; + /** * 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 (ServerInstance->Config->global_implementation[y] > 0) { \ - for (int _i = 0; _i <= MODCOUNT; _i++) { \ + for (int _i = 0; _i <= ServerInstance->GetModuleCount(); _i++) { \ if (ServerInstance->Config->implement_lists[_i][y]) \ try \ { \ - modules[_i]->x ; \ + ServerInstance->modules[_i]->x ; \ } \ - catch (ModuleException& modexcept) \ + catch (CoreException& modexcept) \ { \ - log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); \ + ServerInstance->Log(DEFAULT,"Exception cought: %s",modexcept.GetReason()); \ } \ } \ } #define FOREACH_MOD_I(z,y,x) if (z->Config->global_implementation[y] > 0) { \ - for (int _i = 0; _i <= MODCOUNT; _i++) { \ + for (int _i = 0; _i <= z->GetModuleCount(); _i++) { \ if (z->Config->implement_lists[_i][y]) \ try \ { \ - modules[_i]->x ; \ + z->modules[_i]->x ; \ } \ - catch (ModuleException& modexcept) \ + catch (CoreException& modexcept) \ { \ - log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); \ + z->Log(DEFAULT,"Exception cought: %s",modexcept.GetReason()); \ } \ } \ } @@ -123,19 +144,19 @@ typedef std::map featurelist; */ #define FOREACH_RESULT(y,x) { if (ServerInstance->Config->global_implementation[y] > 0) { \ MOD_RESULT = 0; \ - for (int _i = 0; _i <= MODCOUNT; _i++) { \ + for (int _i = 0; _i <= ServerInstance->GetModuleCount(); _i++) { \ if (ServerInstance->Config->implement_lists[_i][y]) { \ try \ { \ - int res = modules[_i]->x ; \ + int res = ServerInstance->modules[_i]->x ; \ if (res != 0) { \ MOD_RESULT = res; \ break; \ } \ } \ - catch (ModuleException& modexcept) \ + catch (CoreException& modexcept) \ { \ - log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \ + ServerInstance->Log(DEFAULT,"Exception cought: %s",modexcept.GetReason()); \ } \ } \ } \ @@ -144,19 +165,19 @@ typedef std::map featurelist; #define FOREACH_RESULT_I(z,y,x) { if (z->Config->global_implementation[y] > 0) { \ MOD_RESULT = 0; \ - for (int _i = 0; _i <= MODCOUNT; _i++) { \ + for (int _i = 0; _i <= z->GetModuleCount(); _i++) { \ if (z->Config->implement_lists[_i][y]) { \ try \ { \ - int res = modules[_i]->x ; \ + int res = z->modules[_i]->x ; \ if (res != 0) { \ MOD_RESULT = res; \ break; \ } \ } \ - catch (ModuleException& modexcept) \ + catch (CoreException& modexcept) \ { \ - log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \ + z->Log(DEBUG,"Exception cought: %s",modexcept.GetReason()); \ } \ } \ } \ @@ -167,9 +188,11 @@ typedef std::map featurelist; // useful macros -#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) +#define IS_LOCAL(x) ((x->GetFd() > -1) && (x->GetFd() <= MAX_DESCRIPTORS)) +#define IS_REMOTE(x) (x->GetFd() < 0) +#define IS_MODULE_CREATED(x) (x->GetFd() == FD_MAGIC_NUMBER) +#define IS_OPER(x) (*x->oper) +#define IS_AWAY(x) (*x->awaymsg) /** Holds a module's Version information * The four members (set by the constructor only) indicate details as to the version number @@ -178,20 +201,17 @@ typedef std::map featurelist; class Version : public classbase { public: - const int Major, Minor, Revision, Build, Flags; - Version(int major, int minor, int revision, int build, int flags); + const int Major, Minor, Revision, Build, Flags, API; + Version(int major, int minor, int revision, int build, int flags, int api_ver); }; /** 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. */ -class ModuleMessage : public classbase +class ModuleMessage : public Extensible { public: - /** This class is pure virtual and must be inherited. - */ - virtual char* Send() = 0; virtual ~ModuleMessage() {}; }; @@ -295,7 +315,7 @@ class Event : public ModuleMessage * The return result of an Event::Send() will always be NULL as * no replies are expected. */ - char* Send(); + char* Send(InspIRCd* ServerInstance); }; /** This class can be used on its own to represent an exception, or derived to represent a module-specific exception. @@ -304,23 +324,29 @@ class Event : public ModuleMessage * 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 : public classbase +class CoreException : public std::exception { - private: + protected: /** Holds the error message to be displayed */ - std::string err; + const std::string err; + const std::string source; public: - /** Default constructor, just uses the error mesage 'Module threw an exception'. + /** Default constructor, just uses the error mesage 'Core threw an exception'. */ - ModuleException() : err("Module threw an exception") {} + CoreException() : err("Core threw an exception"), source("The core") {} /** This constructor can be used to specify an error message before throwing. */ - ModuleException(std::string message) : err(message) {} + CoreException(const std::string &message) : err(message), source("The core") {} + /** This constructor can be used to specify an error message before throwing, + * and to specify the source of the exception. + */ + CoreException(const std::string &message, const std::string &src) : err(message), source(src) {} /** This destructor solves world hunger, cancels the world debt, and causes the world to end. * Actually no, it does nothing. Never mind. + * @throws Nothing! */ - virtual ~ModuleException() {}; + virtual ~CoreException() throw() {}; /** Returns the reason for the exception. * The module should probably put something informative here as the user will see this upon failure. */ @@ -328,6 +354,28 @@ class ModuleException : public classbase { return err.c_str(); } + + virtual const char* GetSource() + { + return source.c_str(); + } +}; + +class ModuleException : public CoreException +{ + public: + /** Default constructor, just uses the error mesage 'Module threw an exception'. + */ + ModuleException() : CoreException("Module threw an exception", "A Module") {} + + /** This constructor can be used to specify an error message before throwing. + */ + ModuleException(const std::string &message) : CoreException(message, "A Module") {} + /** This destructor solves world hunger, cancels the world debt, and causes the world to end. + * Actually no, it does nothing. Never mind. + * @throws Nothing! + */ + virtual ~ModuleException() throw() {}; }; /** Priority types which can be returned from Module::Prioritize() @@ -343,11 +391,12 @@ enum Implementation { I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUse 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_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, I_OnRawMode, I_OnCheckInvite, + I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnUserRrgister, 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_OnPostLocalTopicChange, I_OnEvent, I_OnRequest, I_OnOperCompre, I_OnGlobalOper, I_OnPostConnect, I_OnAddBan, I_OnDelBan, I_OnRawSocketAccept, I_OnRawSocketClose, I_OnRawSocketWrite, I_OnRawSocketRead, I_OnChangeLocalUserGECOS, I_OnUserRegister, - I_OnOperCompare, I_OnChannelDelete, I_OnPostOper, I_OnSyncOtherMetaData, I_OnSetAway, I_OnCancelAway }; + I_OnOperCompare, I_OnChannelDelete, I_OnPostOper, I_OnSyncOtherMetaData, I_OnSetAway, I_OnCancelAway, I_OnUserList, + I_OnPostCommand, I_OnPostJoin, I_OnWhoisLine, I_OnBuildExemptList, I_OnRawSocketConnect, I_OnGarbageCollect, I_OnBufferFlushed }; /** Base class for all InspIRCd modules * This class is the base class for InspIRCd modules. All modules must inherit from this class, @@ -356,14 +405,16 @@ enum Implementation { I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUse */ class Module : public Extensible { + protected: + InspIRCd* ServerInstance; public: /** Default constructor * Creates a module class. - * @param Me An instance of the Server class which can be saved for future use + * @param Me An instance of the InspIRCd class which will be saved into ServerInstance for your use * \exception ModuleException Throwing this class, or any class derived from ModuleException, causes loading of the module to abort. */ - Module(Server* Me); + Module(InspIRCd* Me); /** Default destructor * destroys a module class @@ -400,9 +451,9 @@ class Module : public Extensible * * PRIORITY_DONTCARE - To leave your module as it is (this is the default value, if you do not implement this function) * - * The result of Server::PriorityBefore() - To move your module before another named module + * The result of InspIRCd::PriorityBefore() - To move your module before another named module * - * The result of Server::PriorityLast() - To move your module after another named module + * The result of InspIRCd::PriorityLast() - To move your module after another named module * * For a good working example of this method call, please see src/modules/m_spanningtree.cpp * and src/modules/m_hostchange.so which make use of it. It is highly recommended that unless @@ -422,9 +473,10 @@ class Module : public Extensible * This event is only called when the user is fully registered when they quit. To catch * raw disconnections, use the OnUserDisconnect method. * @param user The user who is quitting - * @param message The user's quit message + * @param message The user's quit message (as seen by non-opers) + * @param oper_message The user's quit message (as seen by opers) */ - virtual void OnUserQuit(userrec* user, const std::string &message); + virtual void OnUserQuit(userrec* user, const std::string &message, const std::string &oper_message); /** Called whenever a user's socket is closed. * The details of the exiting user are available to you in the parameter userrec *user @@ -444,8 +496,18 @@ class Module : public Extensible * and the details of the channel they have joined is available in the variable chanrec *channel * @param user The user who is joining * @param channel The channel being joined + * @param silent Change this to true if you want to conceal the JOIN command from the other users + * of the channel (useful for modules such as auditorium) + */ + virtual void OnUserJoin(userrec* user, chanrec* channel, bool &silent); + + /** Called after a user joins a channel + * Identical to OnUserJoin, but called immediately afterwards, when any linking module has + * seen the join. + * @param user The user who is joining + * @param channel The channel being joined */ - virtual void OnUserJoin(userrec* user, chanrec* channel); + virtual void OnPostJoin(userrec* user, chanrec* channel); /** Called when a user parts a channel. * The details of the leaving user are available to you in the parameter userrec *user, @@ -453,17 +515,21 @@ class Module : public Extensible * @param user The user who is parting * @param channel The channel being parted * @param partmessage The part message, or an empty string + * @param silent Change this to true if you want to conceal the PART command from the other users + * of the channel (useful for modules such as auditorium) */ - virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage); + virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage, bool &silent); /** Called on rehash. * This method is called prior to a /REHASH or when a SIGHUP is received from the operating * system. You should use it to reload any files so that your module keeps in step with the * rest of the application. If a parameter is given, the core has done nothing. The module * receiving the event can decide if this parameter has any relevence to it. + * @param user The user performing the rehash, if any -- if this is server initiated, the + * value of this variable will be NULL. * @param parameter The (optional) parameter given to REHASH from the user. */ - virtual void OnRehash(const std::string ¶meter); + virtual void OnRehash(userrec* user, const std::string ¶meter); /** Called when a raw command is transmitted or received. * This method is the lowest level of handler available to a module. It will be called with raw @@ -491,10 +557,13 @@ class Module : public Extensible * processing on the actual channel record at this point, however the channel NAME will still be passed in * char* cname, so that you could for example implement a channel blacklist or whitelist, etc. * @param user The user joining the channel - * @param cname The channel name being joined + * @param chan If the channel is a new channel, this will be NULL, otherwise it will be a pointer to the channel being joined + * @param cname The channel name being joined. For new channels this is valid where chan is not. + * @param privs A string containing the users privilages when joining the channel. For new channels this will contain "@". + * You may alter this string to alter the user's modes on the channel. * @return 1 To prevent the join, 0 to allow it. */ - virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname); + virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname, std::string &privs); /** Called whenever a user is about to be kicked. * Returning a value of 1 from this function stops the process immediately, causing no @@ -515,8 +584,10 @@ class Module : public Extensible * @param user The user being kicked * @param chan The channel the user is being kicked from * @param reason The kick reason + * @param silent Change this to true if you want to conceal the PART command from the other users + * of the channel (useful for modules such as auditorium) */ - virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason); + virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason, bool &silent); /** Called whenever a user opers locally. * The userrec will contain the oper mode 'o' as this function is called after any modifications @@ -587,9 +658,11 @@ class Module : public Extensible * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL) * @param text Changeable text being sent by the user * @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone. + * @param exempt_list A list of users not to send to. For channel messages, this will usually contain just the sender. + * It will be ignored for private messages. * @return 1 to deny the NOTICE, 0 to allow it */ - virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text,char status); + virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list); /** Called whenever a user is about to NOTICE A user or a channel, before any processing is done. * Returning any nonzero value from this function stops the process immediately, causing no @@ -606,9 +679,21 @@ class Module : public Extensible * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL) * @param text Changeable text being sent by the user * @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone. + * @param exempt_list A list of users not to send to. For channel notices, this will usually contain just the sender. + * It will be ignored for private notices. * @return 1 to deny the NOTICE, 0 to allow it */ - virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text,char status); + virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list); + + /** Called whenever the server wants to build the exemption list for a channel, but is not directly doing a PRIVMSG or NOTICE. + * For example, the spanningtree protocol will call this event when passing a privmsg on (but not processing it directly). + * @param message_type The message type, either MSG_PRIVMSG or MSG_NOTICE + * @param chan The channel to build the exempt list of + * @param sender The original sender of the PRIVMSG or NOTICE + * @param status The status char to be used for the channel list + * @param exempt_list The exempt list to be populated + */ + virtual void OnBuildExemptList(MessageType message_type, chanrec* chan, userrec* sender, char status, CUList &exempt_list); /** Called before any nickchange, local or remote. This can be used to implement Q-lines etc. * Please note that although you can see remote nickchanges through this function, you should @@ -631,7 +716,7 @@ class Module : public Extensible * @param text the text being sent by the user * @param status The status being used, e.g. PRIVMSG @#chan has status== '@', 0 to send to everyone. */ - virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status); + virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); /** Called after any NOTICE sent from a user. * The dest variable contains a userrec* if target_type is TYPE_USER and a chanrec* @@ -642,7 +727,7 @@ class Module : public Extensible * @param text the text being sent by the user * @param status The status being used, e.g. NOTICE @#chan has status== '@', 0 to send to everyone. */ - virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status); + virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list); /** Called after every MODE command sent from a user * The dest variable contains a userrec* if target_type is TYPE_USER and a chanrec* @@ -988,21 +1073,36 @@ class Module : public Extensible /** 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 - * exist within the command table). By returning 1 from this method you may prevent the + * or another module, and for invalid commands. Invalid commands may only be sent to this + * function when the value of validated is false. By returning 1 from this method you may prevent the * command being executed. If you do this, no output is created by the core, and it is * down to your module to produce any output neccessary. * Note that unless you return 1, you should not destroy any structures (e.g. by using - * Server::QuitUser) otherwise when the command's handler function executes after your + * InspIRCd::QuitUser) otherwise when the command's handler function executes after your * method returns, it will be passed an invalid pointer to the user object and crash!) * @param command The command being executed * @param parameters An array of array of characters containing the parameters for the command * @param pcnt The nuimber of parameters passed to the command * @param user the user issuing the command * @param validated True if the command has passed all checks, e.g. it is recognised, has enough parameters, the user has permission to execute it, etc. + * @param original_line The entire original line as passed to the parser from the user * @return 1 to block the command, 0 to allow */ - virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated); + virtual int OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line); + + /** Called after any command has been 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 + * exist within the command table). The result code returned by the command handler is + * provided. + * @param command The command being executed + * @param parameters An array of array of characters containing the parameters for the command + * @param pcnt The nuimber of parameters passed to the command + * @param user the user issuing the command + * @param result The return code given by the command handler, one of CMD_SUCCESS or CMD_FAILURE + * @param original_line The entire original line as passed to the parser from the user + */ + virtual void OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result, const std::string &original_line); /** Called to check if a user who is connecting can now be allowed to register * If any modules return false for this function, the user is held in the waiting @@ -1023,22 +1123,9 @@ class Module : public Extensible * Note that you should NOT delete the user record here by causing a disconnection! * Use OnUserConnect for that instead. * @param user The user registering + * @return 1 to indicate user quit, 0 to continue */ - virtual void OnUserRegister(userrec* user); - - /** Called whenever a mode character is processed. - * Return 1 from this function to block the mode character from being processed entirely, - * so that you may perform your own code instead. Note that this method allows you to override - * modes defined by other modes, but this is NOT RECOMMENDED! - * @param user The user who is sending the mode - * @param chan The channel the mode is being sent to - * @param mode The mode character being set - * @param param The parameter for the mode or an empty string - * @param adding true of the mode is being added, false if it is being removed - * @param pcnt The parameter count for the mode (0 or 1) - * @return 1 to deny the mode, 0 to allow - */ - virtual int OnRawMode(userrec* user, chanrec* chan, char mode, const std::string ¶m, bool adding, int pcnt); + virtual int OnUserRegister(userrec* user); /** Called whenever a user joins a channel, to determine if invite checks should go ahead or not. * This method will always be called for each join, wether or not the channel is actually +i, and @@ -1085,7 +1172,9 @@ class Module : public Extensible * This method is triggered for all /STATS use, including stats symbols handled by the core. * @param symbol the symbol provided to /STATS * @param user the user issuing the /STATS command - * @param results A string_list to append results into + * @param results A string_list to append results into. You should put all your results + * into this string_list, rather than displaying them directly, so that your handler will + * work when remote STATS queries are received. * @return 1 to block the /STATS from being processed by the core, 0 to allow it */ virtual int OnStats(char symbol, userrec* user, string_list &results); @@ -1147,9 +1236,10 @@ class Module : public Extensible * to do nothing. * @param password The oper's password * @param input The password entered - * @return 1 to match the passwords, 0 to do nothing + * @param tagnumber The tag number (from the configuration file) of this oper's tag + * @return 1 to match the passwords, 0 to do nothing. -1 to not match, and not continue. */ - virtual int OnOperCompare(const std::string &password, const std::string &input); + virtual int OnOperCompare(const std::string &password, const std::string &input, int tagnumber); /** Called whenever a user is given usermode +o, anywhere on the network. * You cannot override this and prevent it from happening as it is already happened and @@ -1159,12 +1249,13 @@ class Module : public Extensible */ virtual void OnGlobalOper(userrec* user); - /** Called whenever a user connects, anywhere on the network. + /** Called after a user has fully connected and all modules have executed OnUserConnect * This event is informational only. You should not change any user information in this * event. To do so, use the OnUserConnect method to change the state of local users. + * This is called for both local and remote users. * @param user The user who is connecting */ - virtual void OnGlobalConnect(userrec* user); + virtual void OnPostConnect(userrec* user); /** Called whenever a ban is added to a channel's list. * Return a non-zero value to 'eat' the mode change and prevent the ban from being added. @@ -1213,6 +1304,8 @@ class Module : public Extensible */ virtual void OnRawSocketClose(int fd); + virtual void OnRawSocketConnect(int fd); + /** Called immediately before any read() operation on a client socket in the core. * This occurs AFTER the select() or poll() so there is always data waiting to be read * when this event occurs. @@ -1239,285 +1332,42 @@ class Module : public Extensible /** Called when a user cancels their away state. */ virtual void OnCancelAway(userrec* user); -}; - -/** Allows server output and query functions - * This class contains methods which allow a module to query the state of the irc server, and produce - * 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 Extensible -{ - public: - /** For use with Module::Prioritize(). - * When the return value of this function is returned from - * Module::Prioritize(), this specifies that the module wishes - * to be ordered exactly BEFORE 'modulename'. For more information - * please see Module::Prioritize(). - * @param modulename The module your module wants to be before in the call list - * @returns a priority ID which the core uses to relocate the module in the list - */ - long PriorityBefore(const std::string &modulename); - - /** For use with Module::Prioritize(). - * When the return value of this function is returned from - * Module::Prioritize(), this specifies that the module wishes - * to be ordered exactly AFTER 'modulename'. For more information please - * see Module::Prioritize(). - * @param modulename The module your module wants to be after in the call list - * @returns a priority ID which the core uses to relocate the module in the list - */ - long PriorityAfter(const std::string &modulename); - - /** 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); - - /** Returns true if a nick is valid. - * Nicks for unregistered connections will return false. - */ - bool IsNick(const std::string &nick); - - /** Attempts to look up a nick using the file descriptor associated with that nick. - * This function will return NULL if the file descriptor is not associated with a valid user. - */ - userrec* FindDescriptor(int socket); - - bool AddMode(ModeHandler* mh, const unsigned char modechar); - - bool AddModeWatcher(ModeWatcher* mw); - - bool DelModeWatcher(ModeWatcher* mw); - - bool AddResolver(Resolver* r); - - /** 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 - * module which is is of type handlerfunc: - * - * typedef void (handlerfunc) (char**, int, userrec*); - * ... - * void handle_kill(char **parameters, int pcnt, userrec *user) - * - * When the command is typed, the parameters will be placed into the parameters array (similar to argv) and - * the parameter count will be placed into pcnt (similar to argv). There will never be any less parameters - * than the 'minparams' value you specified when creating the command. The *user parameter is the class of - * the user which caused the command to trigger, who will always have the flag you specified in 'flags' when - * creating the initial command. For example to create an oper only command create the commands with flags='o'. - * The source parameter is used for resource tracking, and should contain the name of your module (with file - * extension) e.g. "m_blarp.so". If you place the wrong identifier here, you can cause crashes if your module - * is unloaded. - */ - void AddCommand(command_t *f); - - /** Sends a servermode. - * you must format the parameters array with the target, modes and parameters for those modes. - * - * For example: - * - * char *modes[3]; - * - * modes[0] = ChannelName; - * - * modes[1] = "+o"; - * - * modes[2] = user->nick; - * - * Srv->SendMode(modes,3,user); - * - * The modes will originate from the server where the command was issued, however responses (e.g. numerics) - * will be sent to the user you provide as the third parameter. - * You must be sure to get the number of parameters correct in the pcnt parameter otherwise you could leave - * your server in an unstable state! - */ - void SendMode(const char **parameters, int pcnt, userrec *user); - - /** Matches text against a glob pattern. - * Uses the ircd's internal matching function to match string against a globbing pattern, e.g. *!*@*.com - * Returns true if the literal successfully matches the pattern, false if otherwise. - */ - bool MatchText(const std::string &sliteral, const std::string &spattern); - - /** Calls the handler for a command, either implemented by the core or by another module. - * You can use this function to trigger other commands in the ircd, such as PRIVMSG, JOIN, - * KICK etc, or even as a method of callback. By defining command names that are untypeable - * for users on irc (e.g. those which contain a \r or \n) you may use them as callback identifiers. - * The first parameter to this method is the name of the command handler you wish to call, e.g. - * PRIVMSG. This will be a command handler previously registered by the core or wih AddCommand(). - * The second parameter is an array of parameters, and the third parameter is a count of parameters - * in the array. If you do not pass enough parameters to meet the minimum needed by the handler, the - * functiom will silently ignore it. The final parameter is the user executing the command handler, - * used for privilage checks, etc. - * @return True if the command exists - */ - bool CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user); - - /** This function returns true if the commandname exists, pcnt is equal to or greater than the number - * of paramters the command requires, the user specified is allowed to execute the command, AND - * if the command is implemented by a module (not the core). This has a few specific uses, usually - * within network protocols (see src/modules/m_spanningtree.cpp) - */ - bool IsValidModuleCommand(const std::string &commandname, int pcnt, userrec* user); - - /** Returns true if the servername you give is ulined. - * ULined servers have extra privilages. They are allowed to change nicknames on remote servers, - * change modes of clients which are on remote servers and set modes of channels where there are - * no channel operators for that channel on the ulined server, amongst other things. - */ - bool IsUlined(const std::string &server); - - /** Adds a G-line - * The G-line is propogated to all of the servers in the mesh and enforced as soon as it is added. - * The duration must be in seconds, however you can use the Server::CalcDuration method to convert - * durations into the 1w2d3h3m6s format used by /GLINE etc. The source is an arbitary string used - * to indicate who or what sent the data, usually this is the nickname of a person, or a server - * name. - */ - void AddGLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask); - - /** Adds a Q-line - * The Q-line is propogated to all of the servers in the mesh and enforced as soon as it is added. - * The duration must be in seconds, however you can use the Server::CalcDuration method to convert - * durations into the 1w2d3h3m6s format used by /GLINE etc. The source is an arbitary string used - * to indicate who or what sent the data, usually this is the nickname of a person, or a server - * name. - */ - 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. - * The duration must be in seconds, however you can use the Server::CalcDuration method to convert - * durations into the 1w2d3h3m6s format used by /GLINE etc. The source is an arbitary string used - * to indicate who or what sent the data, usually this is the nickname of a person, or a server - * name. - */ - void AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr); - - /** Adds a K-line - * The K-line is enforced as soon as it is added. - * The duration must be in seconds, however you can use the Server::CalcDuration method to convert - * durations into the 1w2d3h3m6s format used by /GLINE etc. The source is an arbitary string used - * to indicate who or what sent the data, usually this is the nickname of a person, or a server - * name. - */ - void AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask); - - /** Adds a E-line - * The E-line is enforced as soon as it is added. - * The duration must be in seconds, however you can use the Server::CalcDuration method to convert - * durations into the 1w2d3h3m6s format used by /GLINE etc. The source is an arbitary string used - * to indicate who or what sent the data, usually this is the nickname of a person, or a server - * name. - */ - void AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask); - - /** Deletes a G-Line from all servers - */ - bool DelGLine(const std::string &hostmask); - - /** Deletes a Q-Line from all servers - */ - bool DelQLine(const std::string &nickname); - - /** Deletes a Z-Line from all servers - */ - bool DelZLine(const std::string &ipaddr); - - /** Deletes a local K-Line - */ - bool DelKLine(const std::string &hostmask); - - /** Deletes a local E-Line - */ - bool DelELine(const std::string &hostmask); - - /** Calculates a duration - * This method will take a string containing a formatted duration (e.g. "1w2d") and return its value - * as a total number of seconds. This is the same function used internally by /GLINE etc to set - * the ban times. - */ - long CalcDuration(const std::string &duration); - - /** Returns true if a nick!ident@host string is correctly formatted, false if otherwise. - */ - bool IsValidMask(const std::string &mask); - - /** This function finds a module by name. - * You must provide the filename of the module. If the module cannot be found (is not loaded) - * the function will return NULL. - */ - Module* FindModule(const std::string &name); - - /** Adds a class derived from InspSocket to the server's socket engine. - */ - void AddSocket(InspSocket* sock); - - /** Forcibly removes a class derived from InspSocket from the servers socket engine. - */ - void RemoveSocket(InspSocket* sock); - - /** Deletes a class derived from InspSocket from the server's socket engine. - */ - 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! - */ - void RehashServer(); - - /** This method returns the total number of channels on the network. - */ - 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. - */ - chanrec* GetChannelIndex(long index); - - /** 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); + /** Called whenever a NAMES list is requested. + * You can produce the nameslist yourself, overriding the current list, + * and if you do you must return 1. If you do not handle the names list, + * return 0. + */ + virtual int OnUserList(userrec* user, chanrec* Ptr); + + /** Called whenever a line of WHOIS output is sent to a user. + * You may change the numeric and the text of the output by changing + * the values numeric and text, but you cannot change the user the + * numeric is sent to. You may however change the user's userrec values. + * @param user The user the numeric is being sent to + * @param dest The user being WHOISed + * @param numeric The numeric of the line being sent + * @param text The text of the numeric, including any parameters + * @return nonzero to drop the line completely so that the user does not + * receive it, or zero to allow the line to be sent. + */ + virtual int OnWhoisLine(userrec* user, userrec* dest, int &numeric, std::string &text); + + /** Called at intervals for modules to garbage-collect any hashes etc. + * Certain data types such as hash_map 'leak' buckets, which must be + * tidied up and freed by copying into a new item every so often. This + * method is called when it is time to do that. + */ + virtual void OnGarbageCollect(); + + /** Called whenever a user's write buffer has been completely sent. + * This is called when the user's write buffer is completely empty, and + * there are no more pending bytes to be written and no pending write events + * in the socket engine's queue. This may be used to refill the buffer with + * data which is being spooled in a controlled manner, e.g. LIST lines. + * @param user The user who's buffer is now empty. + */ + virtual void OnBufferFlushed(userrec* user); }; @@ -1536,6 +1386,7 @@ class Server : public Extensible class ConfigReader : public classbase { protected: + InspIRCd* ServerInstance; /** The contents of the configuration file * This protected member should never be accessed by a module (and cannot be accessed unless the * core is changed). It will contain a pointer to the configuration file data with unneeded data @@ -1554,26 +1405,42 @@ class ConfigReader : public classbase * This constructor initialises the ConfigReader class to read the inspircd.conf file * as specified when running ./configure. */ - ConfigReader(); // default constructor reads ircd.conf + ConfigReader(InspIRCd* Instance); /** Overloaded constructor. * This constructor initialises the ConfigReader class to read a user-specified config file */ - ConfigReader(const std::string &filename); // read a module-specific config + ConfigReader(InspIRCd* Instance, const std::string &filename); /** Default destructor. * This method destroys the ConfigReader class. */ ~ConfigReader(); + /** Retrieves a value from the config file. * This method retrieves a value from the config file. Where multiple copies of the tag * exist in the config file, index indicates which of the values to retrieve. */ - std::string ReadValue(const std::string &tag, const std::string &name, int index); + std::string ReadValue(const std::string &tag, const std::string &name, int index, bool allow_linefeeds = false); + /** Retrieves a value from the config file. + * This method retrieves a value from the config file. Where multiple copies of the tag + * exist in the config file, index indicates which of the values to retrieve. If the + * tag is not found the default value is returned instead. + */ + std::string ReadValue(const std::string &tag, const std::string &name, const std::string &default_value, int index, bool allow_linefeeds = false); + /** Retrieves a boolean value from the config file. * This method retrieves a boolean value from the config file. Where multiple copies of the tag * exist in the config file, index indicates which of the values to retrieve. The values "1", "yes" * and "true" in the config file count as true to ReadFlag, and any other value counts as false. */ bool ReadFlag(const std::string &tag, const std::string &name, int index); + /** Retrieves a boolean value from the config file. + * This method retrieves a boolean value from the config file. Where multiple copies of the tag + * exist in the config file, index indicates which of the values to retrieve. The values "1", "yes" + * and "true" in the config file count as true to ReadFlag, and any other value counts as false. + * If the tag is not found, the default value is used instead. + */ + bool ReadFlag(const std::string &tag, const std::string &name, const std::string &default_value, int index); + /** Retrieves an integer value from the config file. * This method retrieves an integer value from the config file. Where multiple copies of the tag * exist in the config file, index indicates which of the values to retrieve. Any invalid integer @@ -1583,6 +1450,16 @@ class ConfigReader : public classbase * will return CONF_NOT_UNSIGNED */ long ReadInteger(const std::string &tag, const std::string &name, int index, bool needs_unsigned); + /** Retrieves an integer value from the config file. + * This method retrieves an integer value from the config file. Where multiple copies of the tag + * exist in the config file, index indicates which of the values to retrieve. Any invalid integer + * values in the tag will cause the objects error value to be set, and any call to GetError() will + * return CONF_INVALID_NUMBER to be returned. needs_unsigned is set if the number must be unsigned. + * If a signed number is placed into a tag which is specified unsigned, 0 will be returned and GetError() + * will return CONF_NOT_UNSIGNED. If the tag is not found, the default value is used instead. + */ + long ReadInteger(const std::string &tag, const std::string &name, const std::string &default_value, int index, bool needs_unsigned); + /** Returns the last error to occur. * Valid errors can be found by looking in modules.h. Any nonzero value indicates an error condition. * A call to GetError() resets the error flag back to 0. @@ -1625,6 +1502,7 @@ class ConfigReader : public classbase */ class FileReader : public classbase { + InspIRCd* ServerInstance; /** The file contents */ file_cache fc; @@ -1638,14 +1516,14 @@ class FileReader : public classbase * This method does not load any file into memory, you must use the LoadFile method * after constructing the class this way. */ - FileReader(); + FileReader(InspIRCd* Instance); /** Secondary constructor. * This method initialises the class with a file loaded into it ready for GetLine and * and other methods to be called. If the file could not be loaded, FileReader::FileSize * returns 0. */ - FileReader(const std::string &filename); + FileReader(InspIRCd* Instance, const std::string &filename); /** Default destructor. * This deletes the memory allocated to the file. @@ -1687,7 +1565,7 @@ class FileReader : public classbase }; -/** Instantiates classes inherited from Module +/** Instantiates classes inherited from Module. * This class creates a class inherited from type Module, using new. This is to allow for modules * to create many different variants of Module, dependent on architecture, configuration, etc. * In most cases, the simple class shown in the example module m_foobar.so will suffice for most @@ -1696,18 +1574,29 @@ class FileReader : public classbase class ModuleFactory : public classbase { public: + /** The default constructor does nothing. + */ ModuleFactory() { } + /** The default destructor does nothing + */ virtual ~ModuleFactory() { } /** Creates a new module. * Your inherited class of ModuleFactory must return a pointer to your Module class * using this method. */ - virtual Module * CreateModule(Server* Me) = 0; + virtual Module * CreateModule(InspIRCd* Me) = 0; }; - +/** A DLLFactory (designed to load shared objects) containing a ModuleFactory. + */ typedef DLLFactory ircd_module; + +/** A list of loaded Modules + */ typedef std::vector ModuleList; + +/** A list of loaded ModuleFactories + */ typedef std::vector FactoryList; #endif