+
+ /** Called whenever an unknown token is received in a server to server link.
+ * The token value is the unknown token -- please check that no other modules are using the token
+ * that you use. Returning 1 supresses the 'unknown token type' error which is usually sent to
+ * all opers with +s. The params list is a list of parameters, and if any parameters start with a
+ * colon (:) it is treated as the whole of the last parameter, identical to how RFC messages are
+ * handled. source is the sender of the message, and reply is what should be replied to for a unicast
+ * message. Note that there are not many messages in the mesh protocol which require unicast
+ * messaging. tcp_host is the server name as a string, ipaddr is its ip address in dotted decimal
+ * notation and port is the port number it is using.
+ */
+ virtual int OnMeshToken(char token,string_list params,serverrec* source,serverrec* reply, std::string tcp_host,std::string ipaddr,int port);
+
+ /** Called whenever an Event class is sent to all module by another module.
+ * Please see the documentation of Event::Send() for further information. The Event sent can
+ * always be assumed to be non-NULL, you should *always* check the value of Event::GetEventID()
+ * before doing anything to the event data, and you should *not* change the event data in any way!
+ */
+ virtual void OnEvent(Event* event);
+
+ /** Called whenever a Request class is sent to your module by another module.
+ * Please see the documentation of Request::Send() for further information. The Request sent
+ * can always be assumed to be non-NULL, you should not change the request object or its data.
+ * Your method may return arbitary data in the char* result which the requesting module
+ * may be able to use for pre-determined purposes (e.g. the results of an SQL query, etc).
+ */
+ virtual char* OnRequest(Request* request);
+
+ /** Called whenever an oper password is to be compared to what a user has input.
+ * The password field (from the config file) is in 'password' and is to be compared against
+ * 'input'. This method allows for encryption of oper passwords and much more besides.
+ * You should return a nonzero value if you want to allow the comparison or zero if you wish
+ * to do nothing.
+ */
+ virtual int OnOperCompare(std::string password, std::string input);
+
+ /** 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
+ * such a task must be performed by another server. You can however bounce modes by sending
+ * servermodes out to reverse mode changes.
+ */
+ virtual void OnGlobalOper(userrec* user);
+
+ /** Called whenever a user connects, anywhere on the network.
+ * 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.
+ */
+ virtual void OnGlobalConnect(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.
+ */
+ virtual int OnAddBan(userrec* source, chanrec* channel,std::string banmask);
+
+ /** Called whenever a ban is removed from a channel's list.
+ * Return a non-zero value to 'eat' the mode change and prevent the ban from being removed.
+ */
+ virtual int OnDelBan(userrec* source, chanrec* channel,std::string banmask);
+
+ /** 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.
+ */
+ virtual void OnRawSocketAccept(int fd, std::string ip, int localport);
+
+ /** Called immediately before any write() operation on a user's socket in the core. Because
+ * this event is a low level event no user information is associated with it. It is intended
+ * for use by modules which may wrap connections within another API such as SSL for example.
+ * return a non-zero result if you have handled the write operation, in which case the core
+ * will not call write().
+ */
+ virtual int OnRawSocketWrite(int fd, char* buffer, int count);
+
+ /** Called immediately before any socket is closed. When this event is called, shutdown()
+ * has not yet been called on the socket.
+ */
+ virtual void OnRawSocketClose(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.
+ * Your event should return 1 if it has handled the reading itself, which prevents the core
+ * just using read(). You should place any data read into buffer, up to but NOT GREATER THAN
+ * the value of count. The value of readresult must be identical to an actual result that might
+ * be returned from the read() system call, for example, number of bytes read upon success,
+ * 0 upon EOF or closed socket, and -1 for error. If your function returns a nonzero value,
+ * you MUST set readresult.
+ */
+ virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult);