- Server();
- /** Default destructor.
- * Destroys a Server object.
- */
- virtual ~Server();
-
- /** Sends text to all opers.
- * This method sends a server notice to all opers with the usermode +s.
- */
- virtual void SendOpers(std::string s);
- /** 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.
- */
- virtual void Log(int level, std::string s);
- /** Sends a line of text down a TCP/IP socket.
- * This method writes a line of text to an established socket, cutting it to 510 characters
- * plus a carriage return and linefeed if required.
- */
- virtual void Send(int Socket, std::string s);
- /** Sends text from the server to a socket.
- * This method writes a line of text to an established socket, with the servername prepended
- * as used by numerics (see RFC 1459)
- */
- virtual void SendServ(int Socket, std::string s);
- /** Sends text from a user to a socket.
- * This method writes a line of text to an established socket, with the given user's nick/ident
- * /host combination prepended, as used in PRIVSG etc commands (see RFC 1459)
- */
- virtual void SendFrom(int Socket, userrec* User, std::string s);
- /** Sends text from a user to another user.
- * This method writes a line of text to a user, with a user's nick/ident
- * /host combination prepended, as used in PRIVMSG etc commands (see RFC 1459)
- * If you specify NULL as the source, then the data will originate from the
- * local server, e.g. instead of:
- *
- * :user!ident@host TEXT
- *
- * The format will become:
- *
- * :localserver TEXT
- *
- * Which is useful for numerics and server notices to single users, etc.
- */
- virtual void SendTo(userrec* Source, userrec* Dest, std::string s);
- /** Sends text from a user to a channel (mulicast).
- * This method writes a line of text to a channel, with the given user's nick/ident
- * /host combination prepended, as used in PRIVMSG etc commands (see RFC 1459). If the
- * IncludeSender flag is set, then the text is also sent back to the user from which
- * it originated, as seen in MODE (see RFC 1459).
- */
- virtual void SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender);
- /** Returns true if two users share a common channel.
- * This method is used internally by the NICK and QUIT commands, and the Server::SendCommon
- * method.
- */
- virtual bool CommonChannels(userrec* u1, userrec* u2);
- /** Sends text from a user to one or more channels (mulicast).
- * This method writes a line of text to all users which share a common channel with a given
- * user, with the user's nick/ident/host combination prepended, as used in PRIVMSG etc
- * commands (see RFC 1459). If the IncludeSender flag is set, then the text is also sent
- * 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);
- /** Sends a WALLOPS message.
- * This method writes a WALLOPS message to all users with the +w flag, originating from the
- * specified user.
- */
- virtual void SendWallops(userrec* User, std::string text);
-
- /** Returns true if a nick is valid.
- * Nicks for unregistered connections will return false.
- */
- virtual bool IsNick(std::string nick);
- /** Returns a count of the number of users on a channel.
- * This will NEVER be 0, as if the chanrec exists, it will have at least one user in the channel.
- */
- virtual int CountUsers(chanrec* c);
- /** Attempts to look up a nick and return a pointer to it.
- * This function will return NULL if the nick does not exist.
- */
- virtual userrec* FindNick(std::string nick);
- /** Attempts to look up a channel and return a pointer to it.
- * This function will return NULL if the channel does not exist.
- */
- virtual chanrec* FindChannel(std::string channel);
- /** Attempts to look up a user's privilages on a channel.
- * This function will return a string containing either @, %, +, or an empty string,
- * representing the user's privilages upon the channel you specify.
- */
- virtual std::string ChanMode(userrec* User, chanrec* Chan);
- /** Checks if a user is on a channel.
- * This function will return true or false to indicate if user 'User' is on channel 'Chan'.
- */
- virtual bool IsOnChannel(userrec* User, chanrec* Chan);
- /** Returns the server name of the server where the module is loaded.
- */
- virtual std::string GetServerName();
- /** Returns the network name, global to all linked servers.
- */
- virtual std::string GetNetworkName();
- /** Returns the information of the server as returned by the /ADMIN command.
- * See the Admin class for further information of the return value. The members
- * Admin::Nick, Admin::Email and Admin::Name contain the information for the
- * server where the module is loaded.
- */
- 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);
-
- /** 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'.
- */
- virtual void AddCommand(char* cmd, handlerfunc f, char flags, int minparams);
-
- /** 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!
- */
-
- virtual void SendMode(char **parameters, int pcnt, userrec *user);
-
- /** Sends to all users matching a mode mask
- * You must specify one or more usermodes as the first parameter. These can be RFC specified modes such as +i,
- * or module provided modes, including ones provided by your own module.
- * In the second parameter you must place a flag value which indicates wether the modes you have given will be
- * logically ANDed or OR'ed. You may use one of either WM_AND or WM_OR.
- * for example, if you were to use:
- *
- * Serv->SendToModeMask("xi", WM_OR, "m00");
- *
- * Then the text 'm00' will be sent to all users with EITHER mode x or i. Conversely if you used WM_AND, the
- * user must have both modes set to receive the message.
- */
- virtual void SendToModeMask(std::string modes, int flags, std::string text);
-
- /** Forces a user to join a channel.
- * This is similar to svsjoin and can be used to implement redirection, etc.
- * On success, the return value is a valid pointer to a chanrec* of the channel the user was joined to.
- * On failure, the result is NULL.
- */
- virtual chanrec* JoinUserToChannel(userrec* user, std::string cname, std::string key);
-
- /** Forces a user to part a channel.
- * This is similar to svspart and can be used to implement redirection, etc.
- * Although the return value of this function is a pointer to a channel record, the returned data is
- * undefined and should not be read or written to. This behaviour may be changed in a future version.
- */
- virtual chanrec* PartUserFromChannel(userrec* user, std::string cname, std::string reason);
-
- /** Forces a user nickchange.
- * This command works similarly to SVSNICK, and can be used to implement Q-lines etc.
- * If you specify an invalid nickname, the nick change will be dropped and the target user will receive
- * the error numeric for it.
- */
- virtual void ChangeUserNick(userrec* user, std::string nickname);
-
- /** Forces a user to quit with the specified reason.
- * To the user, it will appear as if they typed /QUIT themselves, except for the fact that this function
- * may bypass the quit prefix specified in the config file.
- *
- * WARNING!
- *
- * Once you call this function, userrec* user will immediately become INVALID. You MUST NOT write to, or
- * read from this pointer after calling the QuitUser method UNDER ANY CIRCUMSTANCES! The best course of
- * action after calling this method is to immediately bail from your handler.
- */
- virtual void QuitUser(userrec* user, std::string reason);
-
- /** 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.
- */
- virtual bool MatchText(std::string sliteral, 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.
- */
- virtual void CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user);
-
- /** Change displayed hostname of a user.
- * You should always call this method to change a user's host rather than writing directly to the
- * 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);
-
- /** 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);
-
- /** 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. Ulined server
- * data is also broadcast across the mesh at all times as opposed to selectively messaged in the
- * case of normal servers, as many ulined server types (such as services) do not support meshed
- * links and must operate in this manner.
- */
- virtual bool IsUlined(std::string server);
-
- /** Fetches the userlist of a channel. This function must be here and not a member of userrec or
- * chanrec due to include constraints.
- */
- virtual chanuserlist GetUsers(chanrec* chan);
+ virtual void OnBackgroundTimer(time_t curtime);
+
+ /** 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, 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
+ * 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.
+ * You should only change the parameter list and command string if validated == false (e.g. before the command lookup occurs).
+ * @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(std::string &command, std::vector<std::string>& parameters, User *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 std::vector<std::string>& parameters, User *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
+ * state until all modules return true. For example a module which implements ident
+ * lookups will continue to return false for a user until their ident lookup is completed.
+ * Note that the registration timeout for a user overrides these checks, if the registration
+ * timeout is reached, the user is disconnected even if modules report that the user is
+ * not ready to connect.
+ * @param user The user to check
+ * @return true to indicate readiness, false if otherwise
+ */
+ virtual bool OnCheckReady(User* user);
+
+ /** Called whenever a user is about to register their connection (e.g. before the user
+ * is sent the MOTD etc). Modules can use this method if they are performing a function
+ * which must be done before the actual connection is completed (e.g. ident lookups,
+ * dnsbl lookups, etc).
+ * 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 int OnUserRegister(User* 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
+ * determines the outcome of an if statement around the whole section of invite checking code.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * @param user The user joining the channel
+ * @param chan The channel being joined
+ * @return 1 to explicitly allow the join, 0 to proceed as normal
+ */
+ virtual int OnCheckInvite(User* user, Channel* chan);
+
+ /** Called whenever a mode character is processed.
+ * Return 1 from this function to block the mode character from being processed entirely.
+ * @param user The user who is sending the mode
+ * @param chan The channel the mode is being sent to (or NULL if a usermode)
+ * @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 ACR_DENY to deny the mode, ACR_DEFAULT to do standard mode checking, and ACR_ALLOW
+ * to skip all permission checking. Please note that for remote mode changes, your return value
+ * will be ignored!
+ */
+ virtual int OnRawMode(User* user, Channel* chan, const char mode, const std::string ¶m, bool adding, int pcnt, bool servermode = true);
+
+ /** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
+ * This method will always be called for each join, wether or not the channel is actually +k, and
+ * determines the outcome of an if statement around the whole section of key checking code.
+ * if the user specified no key, the keygiven string will be a valid but empty value.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * @param user The user joining the channel
+ * @param chan The channel being joined
+ * @return 1 to explicitly allow the join, 0 to proceed as normal
+ */
+ virtual int OnCheckKey(User* user, Channel* chan, const std::string &keygiven);
+
+ /** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
+ * This method will always be called for each join, wether or not the channel is actually +l, and
+ * determines the outcome of an if statement around the whole section of channel limit checking code.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * @param user The user joining the channel
+ * @param chan The channel being joined
+ * @return 1 to explicitly allow the join, 0 to proceed as normal
+ */
+ virtual int OnCheckLimit(User* user, Channel* chan);
+
+ /** Called whenever a user joins a channel, to determine if banlist checks should go ahead or not.
+ * This method will always be called for each join, wether or not the user actually matches a channel ban, and
+ * determines the outcome of an if statement around the whole section of ban checking code.
+ * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+ * @param user The user joining the channel
+ * @param chan The channel being joined
+ * @return 1 to explicitly allow the join, 0 to proceed as normal. Return -1 to explicitly deny the
+ * join to the channel.
+ */
+ virtual int OnCheckBan(User* user, Channel* chan);
+
+ /* Called whenever checking whether or not a user is matched by an applicable extended bantype.
+ * NOTE: may also trigger extra OnCheckStringExtBan events!
+ * @param u The user to check
+ * @param c The channel the user is on
+ * @param type The type of extended ban to check for.
+ * @returns 1 = exempt, 0 = no match, -1 = banned
+ */
+ virtual int OnCheckExtBan(User *u, Channel *c, char type);
+
+ /** Called whenever checking whether or not a string is extbanned. NOTE: one OnCheckExtBan will also trigger a number of
+ * OnCheckStringExtBan events for seperate host/IP comnbinations.
+ * @returns 1 = exempt, 0 = no match, -1 = banned
+ */
+ virtual int OnCheckStringExtBan(const std::string &s, Channel *c, char type);
+
+ /** Called on all /STATS commands
+ * 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. 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, User* user, string_list &results);
+
+ /** Called whenever a change of a local users displayed host is attempted.
+ * Return 1 to deny the host change, or 0 to allow it.
+ * @param user The user whos host will be changed
+ * @param newhost The new hostname
+ * @return 1 to deny the host change, 0 to allow
+ */
+ virtual int OnChangeLocalUserHost(User* user, const std::string &newhost);
+
+ /** Called whenever a change of a local users GECOS (fullname field) is attempted.
+ * return 1 to deny the name change, or 0 to allow it.
+ * @param user The user whos GECOS will be changed
+ * @param newhost The new GECOS
+ * @return 1 to deny the GECOS change, 0 to allow
+ */
+ virtual int OnChangeLocalUserGECOS(User* user, const std::string &newhost);
+
+ /** Called whenever a topic is changed by a local user.
+ * Return 1 to deny the topic change, 0 to check details on the change, -1 to let it through with no checks
+ * @param user The user changing the topic
+ * @param chan The channels who's topic is being changed
+ * @param topic The actual topic text
+ * @param 1 to block the topic change, 0 to allow
+ */
+ virtual int OnLocalTopicChange(User* user, Channel* chan, const std::string &topic);
+
+ /** Called whenever a local topic has been changed.
+ * To block topic changes you must use OnLocalTopicChange instead.
+ * @param user The user changing the topic
+ * @param chan The channels who's topic is being changed
+ * @param topic The actual topic text
+ */
+ virtual void OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic);
+
+ /** 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!
+ * @param event The Event class being received
+ */
+ 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).
+ * @param request The Request class being received
+ */
+ virtual const char* 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).
+ * You should return a nonzero value to override the normal comparison, or zero to pass it on.
+ * @param ex The object that's causing the authentication (User* for <oper> <connect:allow> etc, Server* for <link>).
+ * @param password The password from the configuration file (the password="" value).
+ * @param input The password entered by the user or whoever.
+ * @param hashtype The hash value from the config
+ * @return 0 to do nothing (pass on to next module/default), 1 == password is OK, -1 == password is not OK
+ */
+ virtual int OnPassCompare(Extensible* ex, const std::string &password, const std::string &input, const std::string& hashtype);
+
+ /** 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.
+ * @param user The user who is opering
+ */
+ virtual void OnGlobalOper(User* user);
+
+ /** 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 OnPostConnect(User* 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.
+ * @param source The user adding the ban
+ * @param channel The channel the ban is being added to
+ * @param banmask The ban mask being added
+ * @return 1 to block the ban, 0 to continue as normal
+ */
+ virtual int OnAddBan(User* source, Channel* channel,const 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.
+ * @param source The user deleting the ban
+ * @param channel The channel the ban is being deleted from
+ * @param banmask The ban mask being deleted
+ * @return 1 to block the unban, 0 to continue as normal
+ */
+ virtual int OnDelBan(User* source, Channel* channel,const std::string &banmask);
+
+ virtual void OnHookUserIO(User* user);
+
+ /** 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 fd The file descriptor returned from accept()
+ * @param client The client IP address and port
+ * @param server The server IP address and port
+ * @param localport The local port number the user connected to
+ */
+ virtual void OnRawSocketAccept(int fd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server);
+
+ /** 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().
+ * @param fd The file descriptor of the socket
+ * @param buffer A char* buffer being written
+ * @param Number of characters to write
+ * @return Number of characters actually written or 0 if you didn't handle the operation
+ */
+ virtual int OnRawSocketWrite(int fd, const char* buffer, int count);