*/
-#ifndef MODULES_H
-#define MODULES_H
+#pragma once
#include "dynamic.h"
#include "base.h"
#include <sstream>
#include "timer.h"
#include "mode.h"
-#include "dns.h"
/** Used to define a set of behavior bits for a module
*/
/**
* This #define allows us to call a method in all
* loaded modules in a readable simple way, e.g.:
- * 'FOREACH_MOD(I_OnConnect,OnConnect(user));'
+ * 'FOREACH_MOD(OnConnect,(user));'
*/
#define FOREACH_MOD(y,x) do { \
EventHandlerIter safei; \
- for (EventHandlerIter _i = ServerInstance->Modules->EventHandlers[y].begin(); _i != ServerInstance->Modules->EventHandlers[y].end(); ) \
+ IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## y]; \
+ for (EventHandlerIter _i = _handlers.begin(); _i != _handlers.end(); ) \
{ \
safei = _i; \
++safei; \
try \
{ \
- (*_i)->x ; \
+ (*_i)->y x ; \
} \
catch (CoreException& modexcept) \
{ \
- ServerInstance->Logs->Log("MODULE",DEFAULT,"Exception caught: %s",modexcept.GetReason()); \
+ ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: %s",modexcept.GetReason()); \
} \
_i = safei; \
} \
*/
#define DO_EACH_HOOK(n,v,args) \
do { \
- EventHandlerIter iter_ ## n = ServerInstance->Modules->EventHandlers[I_ ## n].begin(); \
- while (iter_ ## n != ServerInstance->Modules->EventHandlers[I_ ## n].end()) \
+ IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## n]; \
+ for (EventHandlerIter _i = _handlers.begin(); _i != _handlers.end(); ++_i) \
{ \
- Module* mod_ ## n = *iter_ ## n; \
- iter_ ## n ++; \
try \
{ \
- v = (mod_ ## n)->n args;
+ v = (*_i)->n args;
#define WHILE_EACH_HOOK(n) \
} \
catch (CoreException& except_ ## n) \
{ \
- ServerInstance->Logs->Log("MODULE",DEFAULT,"Exception caught: %s", (except_ ## n).GetReason()); \
- (void) mod_ ## n; /* catch mismatched pairs */ \
+ ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: %s", (except_ ## n).GetReason()); \
} \
} \
} while(0)
virtual ~Version() {}
};
-/** The Request class is a unicast message directed at a given module.
- * When this class is properly instantiated it may be sent to a module
- * using the Send() method, which will call the given module's OnRequest
- * method with this class as its parameter.
- */
-class CoreExport Request : public classbase
-{
- public:
- /** This should be a null-terminated string identifying the type of request,
- * all modules should define this and use it to determine the nature of the
- * request before they attempt to cast the Request in any way.
- */
- const char* const id;
- /** This is a pointer to the sender of the message, which can be used to
- * directly trigger events, or to create a reply.
- */
- ModuleRef source;
- /** The single destination of the Request
- */
- ModuleRef dest;
-
- /** Create a new Request
- * This is for the 'new' way of defining a subclass
- * of Request and defining it in a common header,
- * passing an object of your Request subclass through
- * as a Request* and using the ID string to determine
- * what to cast it back to and the other end.
- */
- Request(Module* src, Module* dst, const char* idstr);
- /** Send the Request.
- */
- void Send();
-};
-
-
/** The Event class is a unicast message directed at all modules.
* When the class is properly instantiated it may be sent to all modules
* using the Send() method, which will trigger the OnEvent method in
: ServiceProvider(Creator, Name, SERVICE_DATA) {}
};
-class CoreExport dynamic_reference_base : public interfacebase
-{
- private:
- std::string name;
- void resolve();
- protected:
- ServiceProvider* value;
- public:
- ModuleRef creator;
- dynamic_reference_base(Module* Creator, const std::string& Name);
- ~dynamic_reference_base();
- inline const std::string& GetProvider() { return name; }
- void SetProvider(const std::string& newname);
- void check();
- operator bool() { return (value != NULL); }
- static void reset_all();
-};
-
-inline void dynamic_reference_base::check()
-{
- if (!value)
- throw ModuleException("Dynamic reference to '" + name + "' failed to resolve");
-}
-
-template<typename T>
-class dynamic_reference : public dynamic_reference_base
-{
- public:
- dynamic_reference(Module* Creator, const std::string& Name)
- : dynamic_reference_base(Creator, Name) {}
-
- inline T* operator->()
- {
- check();
- return static_cast<T*>(value);
- }
-
- T* operator*()
- {
- return operator->();
- }
-};
-
-template<typename T>
-class dynamic_reference_nocheck : public dynamic_reference_base
-{
- public:
- dynamic_reference_nocheck(Module* Creator, const std::string& Name)
- : dynamic_reference_base(Creator, Name) {}
-
- T* operator->()
- {
- return static_cast<T*>(value);
- }
-
- T* operator*()
- {
- return operator->();
- }
-};
-
-class ModeReference : public dynamic_reference_nocheck<ModeHandler>
-{
- public:
- ModeReference(Module* mod, const std::string& modename)
- : dynamic_reference_nocheck<ModeHandler>(mod, "mode/" + modename) {}
-};
-
/** Priority types which can be used by Module::Prioritize()
*/
enum Priority { PRIORITY_FIRST, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
I_BEGIN,
I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash,
I_OnSendSnotice, 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_OnDecodeMetaData, I_OnWallops, I_OnAcceptConnection, I_OnUserInit,
+ I_OnUserPreInvite, I_OnUserInvite, I_OnUserPreMessage, I_OnUserPreNick,
+ I_OnUserMessage, I_OnMode, I_OnGetServerDescription, I_OnSyncUser,
+ I_OnSyncChannel, I_OnDecodeMetaData, I_OnAcceptConnection, I_OnUserInit,
I_OnChangeHost, I_OnChangeName, I_OnAddLine, I_OnDelLine, I_OnExpireLine,
- I_OnUserPostNick, I_OnPreMode, I_On005Numeric, I_OnKill, I_OnRemoteKill, I_OnLoadModule,
+ I_OnUserPostNick, I_OnPreMode, I_On005Numeric, I_OnKill, I_OnLoadModule,
I_OnUnloadModule, I_OnBackgroundTimer, I_OnPreCommand, I_OnCheckReady, I_OnCheckInvite,
I_OnRawMode, I_OnCheckKey, I_OnCheckLimit, I_OnCheckBan, I_OnCheckChannelBan, I_OnExtBanCheck,
I_OnStats, I_OnChangeLocalUserHost, I_OnPreTopicChange,
*/
DLLManager* ModuleDLLManager;
+ /** If true, this module will be unloaded soon, further unload attempts will fail
+ * Value is used by the ModuleManager internally, you should not modify it
+ */
+ bool dying;
+
/** Default constructor.
* Creates a module class. Don't do any type of hook registration or checks
* for other modules here; do that in init().
* @param keygiven The key given to join the channel, or an empty string if none was provided
* @return 1 To prevent the join, 0 to allow it.
*/
- virtual ModResult OnUserPreJoin(User* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven);
+ virtual ModResult OnUserPreJoin(LocalUser* user, Channel* chan, const std::string& cname, std::string& privs, const std::string& keygiven);
/** Called whenever a user is about to be kicked.
* Returning a value of 1 from this function stops the process immediately, causing no
* @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.
+ * @param msgtype The message type, MSG_PRIVMSG for PRIVMSGs, MSG_NOTICE for NOTICEs
* @return 1 to deny the message, 0 to allow it
*/
- virtual ModResult OnUserPreMessage(User* 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
- * output to be sent to the user by the core. If you do this you must produce your own numerics,
- * notices etc. This is useful for modules which may want to filter or redirect messages.
- * target_type can be one of TYPE_USER or TYPE_CHANNEL. If the target_type value is a user,
- * you must cast dest to a User* otherwise you must cast it to a Channel*, this is the details
- * of where the message is destined to be sent.
- * You may alter the message text as you wish before relinquishing control to the next module
- * in the chain, and if no other modules block the text this altered form of the text will be sent out
- * to the user and possibly to other servers.
- * @param user The user sending the message
- * @param dest The target of the message (Channel* or User*)
- * @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 ModResult OnUserPreNotice(User* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list);
+ virtual ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text,char status, CUList &exempt_list, MessageType msgtype);
/** Called when sending a message to all "neighbors" of a given user -
* that is, all users that share a common channel. This is used in
* @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.
* @param exempt_list A list of users to not send to.
+ * @param msgtype The message type, MSG_PRIVMSG for PRIVMSGs, MSG_NOTICE for NOTICEs
*/
- virtual void OnUserMessage(User* 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 User* if target_type is TYPE_USER and a Channel*
- * if target_type is TYPE_CHANNEL.
- * @param user The user sending the message
- * @param dest The target of the message
- * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
- * @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.
- * @param exempt_list A list of users to not send to.
- */
- virtual void OnUserNotice(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list);
+ virtual void OnUserMessage(User* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list, MessageType msgtype);
/** Called immediately before any NOTICE or PRIVMSG sent from a user, local or remote.
* The dest variable contains a User* if target_type is TYPE_USER and a Channel*
* if target_type is TYPE_CHANNEL.
- * The difference between this event and OnUserPreNotice/OnUserPreMessage is that delivery is gauranteed,
+ * The difference between this event and OnUserPreMessage is that delivery is gauranteed,
* the message has already been vetted. In the case of the other two methods, a later module may stop your
* message. This also differs from OnUserMessage which occurs AFTER the message has been sent.
* @param user The user sending the message
virtual void OnText(User* user, void* dest, int target_type, const std::string &text, char status, CUList &exempt_list);
/** Called after every MODE command sent from a user
- * The dest variable contains a User* if target_type is TYPE_USER and a Channel*
- * if target_type is TYPE_CHANNEL. The text variable contains the remainder of the
- * mode string after the target, e.g. "+wsi" or "+ooo nick1 nick2 nick3".
+ * Either the usertarget or the chantarget variable contains the target of the modes,
+ * the actual target will have a non-NULL pointer.
+ * The modes vector contains the remainder of the mode string after the target,
+ * e.g.: "+wsi" or ["+ooo", "nick1", "nick2", "nick3"].
* @param user The user sending the MODEs
- * @param dest The target of the modes (User* or Channel*)
- * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
- * @param text The actual modes and their parameters if any
+ * @param usertarget The target user of the modes, NULL if the target is a channel
+ * @param chantarget The target channel of the modes, NULL if the target is a user
+ * @param modes The actual modes and their parameters if any
* @param translate The translation types of the mode parameters
*/
- virtual void OnMode(User* user, void* dest, int target_type, const std::vector<std::string> &text, const std::vector<TranslateType> &translate);
+ virtual void OnMode(User* user, User* usertarget, Channel* chantarget, const std::vector<std::string>& modes, const std::vector<TranslateType>& translate);
/** Allows modules to alter or create server descriptions
* Whenever a module requires a server description, for example for display in
*/
virtual void ProtoSendMetaData(void* opaque, Extensible* target, const std::string &extname, const std::string &extdata);
- /** Called after every WALLOPS command.
- * @param user The user sending the WALLOPS
- * @param text The content of the WALLOPS message
- */
- virtual void OnWallops(User* user, const std::string &text);
-
/** Called whenever a user's hostname is changed.
* This event triggers after the host has been set.
* @param user The user whos host is being changed
/** Called when a 005 numeric is about to be output.
* The module should modify the 005 numeric if needed to indicate its features.
- * @param output The 005 map to be modified if neccessary.
+ * @param tokens The 005 map to be modified if neccessary.
*/
virtual void On005Numeric(std::map<std::string, std::string>& tokens);
*/
virtual ModResult OnKill(User* source, User* dest, const std::string &reason);
- /** Called when an oper wants to disconnect a remote user via KILL
- * @param source The user sending the KILL
- * @param dest The user being killed
- * @param reason The kill reason
- * @param operreason The oper kill reason
- */
- virtual void OnRemoteKill(User* source, User* dest, const std::string &reason, const std::string &operreason);
-
/** Called whenever a module is loaded.
* mod will contain a pointer to the module, and string will contain its name,
* for example m_widgets.so. This function is primary for dependency checking,
* @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 std::vector<std::string>& parameters, LocalUser *user, CmdResult result, const std::string &original_line);
+ virtual void OnPostCommand(Command* command, const std::vector<std::string>& parameters, LocalUser* user, CmdResult result, const std::string& original_line);
/** Called when a user is first connecting, prior to starting DNS lookups, checking initial
* connect class, or accepting any commands.
*/
virtual void OnEvent(Event& event);
- /** Called whenever a Request class is sent to your module by another module.
- * The value of Request::id should be used to determine the type of request.
- * @param request The Request class being received
- */
- virtual void OnRequest(Request& request);
-
/** Called whenever a password check is to be made. Replaces the old OldOperCompare API.
* The password field (from the config file) is in 'password' and is to be compared against
* 'input'. This method allows for encryption of passwords (oper, connect:allow, die/restart, etc).
*/
virtual ModResult OnAcceptConnection(int fd, ListenSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
- /** Called immediately after any connection is accepted. This is intended for raw socket
- * processing (e.g. modules which wrap the tcp connection within another library) and provides
- * no information relating to a user record as the connection has not been assigned yet.
- * There are no return values from this call as all modules get an opportunity if required to
- * process the connection.
- * @param sock The socket in question
- * @param client The client IP address and port
- * @param server The server IP address and port
- */
- virtual void OnStreamSocketAccept(StreamSocket* sock, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
-
- /**
- * Called when a hooked stream has data to write, or when the socket
- * engine returns it as writable
- * @param sock The socket in question
- * @param sendq Data to send to the socket
- * @return 1 if the sendq has been completely emptied, 0 if there is
- * still data to send, and -1 if there was an error
- */
- virtual int OnStreamSocketWrite(StreamSocket* sock, std::string& sendq);
-
- /** Called immediately before any socket is closed. When this event is called, shutdown()
- * has not yet been called on the socket.
- * @param sock The socket in question
- */
- virtual void OnStreamSocketClose(StreamSocket* sock);
-
- /** Called immediately upon connection of an outbound BufferedSocket which has been hooked
- * by a module.
- * @param sock The socket in question
- */
- virtual void OnStreamSocketConnect(StreamSocket* sock);
-
- /**
- * Called when the stream socket has data to read
- * @param sock The socket that is ready
- * @param recvq The receive queue that new data should be appended to
- * @return 1 if new data has been read, 0 if no new data is ready (but the
- * socket is still connected), -1 if there was an error or close
- */
- virtual int OnStreamSocketRead(StreamSocket* sock, std::string& recvq);
-
/** Called whenever a user sets away or returns from being away.
* The away message is available as a parameter, but should not be modified.
* At this stage, it has already been copied into the user record.
virtual void OnSetUserIP(LocalUser* user);
};
-/** Caches a text file into memory and can be used to retrieve lines from it.
- * This class contains methods for read-only manipulation of a text file in memory.
- * Either use the constructor type with one parameter to load a file into memory
- * at construction, or use the LoadFile method to load a file.
- */
+/** Provides an easy method of reading a text file into memory. */
class CoreExport FileReader : public classbase
{
- /** The file contents
+ /** The lines of text in the file.
*/
- std::vector<std::string> fc;
+ std::vector<std::string> lines;
/** Content size in bytes
*/
- unsigned long contentsize;
-
- /** Calculate content size in bytes
- */
- void CalcSize();
+ unsigned long totalSize;
public:
- /** Default constructor.
- * This method does not load any file into memory, you must use the LoadFile method
- * after constructing the class this way.
- */
- FileReader();
-
- /** 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);
-
- /** Default destructor.
- * This deletes the memory allocated to the file.
- */
- ~FileReader();
-
- /** Used to load a file.
- * This method loads a file into the class ready for GetLine and
- * and other methods to be called. If the file could not be loaded, FileReader::FileSize
- * returns 0.
+ /** Initializes a new file reader.
*/
- void LoadFile(const std::string &filename);
+ FileReader() : totalSize(0) { }
- /** Returns the whole content of the file as std::string
+ /** Initializes a new file reader and reads the specified file.
+ * @param filename The file to read into memory.
*/
- std::string Contents();
+ FileReader(const std::string& filename);
- /** Returns the entire size of the file as std::string
+ /** Loads a text file from disk.
+ * @param filename The file to read into memory.
+ * @throw CoreException The file can not be loaded.
*/
- unsigned long ContentSize();
+ void Load(const std::string& filename);
- /** Returns true if the file exists
- * This function will return false if the file could not be opened.
+ /** Retrieves the entire contents of the file cache as a single string.
*/
- bool Exists();
+ std::string GetString();
- /** Retrieve one line from the file.
- * This method retrieves one line from the text file. If an empty non-NULL string is returned,
- * the index was out of bounds, or the line had no data on it.
+ /** Retrieves the entire contents of the file cache as a vector of strings.
*/
- std::string GetLine(int x);
+ const std::vector<std::string>& GetVector() { return lines; }
- /** Returns the size of the file in lines.
- * This method returns the number of lines in the read file. If it is 0, no lines have been
- * read into memory, either because the file is empty or it does not exist, or cannot be
- * opened due to permission problems.
- */
- int FileSize();
+ unsigned long TotalSize() { return totalSize; }
};
/** A list of modules
#define COMMAND_INIT(c) MODULE_INIT(CommandModule<c>)
#endif
-
-#endif
projects / user / henk / code / inspircd.git / blobdiff