/**
* 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(); ) \
+ const IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## y]; \
+ for (IntModuleList::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
{ \
- safei = _i; \
- ++safei; \
+ _next = _i+1; \
try \
{ \
- (*_i)->x ; \
+ (*_i)->y x ; \
} \
catch (CoreException& modexcept) \
{ \
ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: %s",modexcept.GetReason()); \
} \
- _i = safei; \
} \
} while (0);
*/
#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()) \
+ const IntModuleList& _handlers = ServerInstance->Modules->EventHandlers[I_ ## n]; \
+ for (IntModuleList::const_reverse_iterator _i = _handlers.rbegin(), _next; _i != _handlers.rend(); _i = _next) \
{ \
- Module* mod_ ## n = *iter_ ## n; \
- iter_ ## n ++; \
+ _next = _i+1; \
try \
{ \
- v = (mod_ ## n)->n args;
+ v = (*_i)->n args;
#define WHILE_EACH_HOOK(n) \
} \
catch (CoreException& except_ ## n) \
{ \
ServerInstance->Logs->Log("MODULE", LOG_DEFAULT, "Exception caught: %s", (except_ ## n).GetReason()); \
- (void) mod_ ## n; /* catch mismatched pairs */ \
} \
} \
} 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_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,
*/
class CoreExport Module : public classbase, public usecountbase
{
+ /** Detach an event from this module
+ * @param i Event type to detach
+ */
+ void DetachEvent(Implementation i);
+
public:
/** File that this module was loaded from
*/
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
/** 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.
FileReader() : totalSize(0) { }
/** Initializes a new file reader and reads the specified file.
- * @param file The file to read into memory.
+ * @param filename The file to read into memory.
*/
FileReader(const std::string& filename);
*/
void DetachAll(Module* mod);
+ /** Attach all events to a module (used on module load)
+ * @param mod Module to attach to all events
+ */
+ void AttachAll(Module* mod);
+
/** Returns text describing the last module error
* @return The last error message to occur
*/
{ \
return new y; \
} \
- extern "C" const char inspircd_src_version[] = VERSION " r" REVISION;
+ extern "C" const char inspircd_src_version[] = VERSION " " REVISION;
#endif
#define COMMAND_INIT(c) MODULE_INIT(CommandModule<c>)
projects / user / henk / code / inspircd.git / blobdiff