X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fmodules.h;h=f15341e017baa3c53e2a2fb6addfd5f140a24f2b;hb=90639721625b5da867effc7dd4adec003c1bd3b4;hp=5939ba0bbae07cf8059c1a8b97b4b88795af47ad;hpb=cdaf7ac3781a0ea1bfbfac85c4a428ddea7725f9;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/include/modules.h b/include/modules.h
index 5939ba0bb..f15341e01 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -60,17 +60,20 @@ enum WriteModeFlags {
 enum TargetTypeFlags {
 	TYPE_USER = 1,
 	TYPE_CHANNEL,
-	TYPE_SERVER
+	TYPE_SERVER,
+	TYPE_OTHER
 };
 
+#include "globals.h"
 #include "dynamic.h"
 #include "base.h"
 #include "ctables.h"
-#include "socket.h"
+#include "inspsocket.h"
 #include <string>
 #include <deque>
 #include <sstream>
 #include <typeinfo>
+#include "timer.h"
 
 class Server;
 class ServerConfig;
@@ -85,38 +88,50 @@ typedef file_cache string_list;
 typedef std::deque<userrec*> chanuserlist;
 
 
-// This #define allows us to call a method in all
-// loaded modules in a readable simple way, e.g.:
-// 'FOREACH_MOD OnConnect(user);'
-
+/**
+ * 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 (Config->global_implementation[y] > 0) { \
 	for (int _i = 0; _i <= MODCOUNT; _i++) { \
 	if (Config->implement_lists[_i][y]) \
-		modules[_i]->x ; \
+		try \
+		{ \
+			modules[_i]->x ; \
+		} \
+		catch (ModuleException& modexcept) \
+		{ \
+			log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); \
+		} \
 	} \
   }
 
-// This define is similar to the one above but returns a result in MOD_RESULT.
-// The first module to return a nonzero result is the value to be accepted,
-// and any modules after are ignored.
-
-// *********************************************************************************************
-
+/**
+ *  This define is similar to the one above but returns a result in MOD_RESULT.
+ * The first module to return a nonzero result is the value to be accepted,
+ * and any modules after are ignored.
+ */
 #define FOREACH_RESULT(y,x) { if (Config->global_implementation[y] > 0) { \
 			MOD_RESULT = 0; \
 			for (int _i = 0; _i <= MODCOUNT; _i++) { \
 			if (Config->implement_lists[_i][y]) {\
-				int res = modules[_i]->x ; \
-				if (res != 0) { \
-					MOD_RESULT = res; \
-					break; \
+				try \
+				{ \
+					int res = modules[_i]->x ; \
+					if (res != 0) { \
+						MOD_RESULT = res; \
+						break; \
+					} \
+				} \
+				catch (ModuleException& modexcept) \
+				{ \
+					log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \
 				} \
 			} \
 		} \
 	} \
  }
-   
-// *********************************************************************************************
 
 #define FD_MAGIC_NUMBER -42
 
@@ -126,12 +141,6 @@ typedef std::deque<userrec*> chanuserlist;
 #define IS_REMOTE(x) (x->fd < 0)
 #define IS_MODULE_CREATED(x) (x->fd == FD_MAGIC_NUMBER)
 
-/*extern void createcommand(char* cmd, handlerfunc f, char flags, int minparams, char* source);
-extern void server_mode(char **parameters, int pcnt, userrec *user);*/
-
-// class Version holds the version information of a Module, returned
-// by Module::GetVersion (thanks RD)
-
 /** Holds a module's Version information
  *  The four members (set by the constructor only) indicate details as to the version number
  *  of a module. A class of type Version is returned by the GetVersion method of the Module class.
@@ -155,13 +164,9 @@ class Admin : public classbase
 	 Admin(std::string name, std::string email, std::string nick);
 };
 
-
 // Forward-delacare module for ModuleMessage etc
 class Module;
 
-// Thanks to Rob (from anope) for the idea of this message passing API
-// (its been done before, but this seemed a very neat and tidy way...
-
 /** 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.
@@ -169,9 +174,9 @@ class Module;
 class ModuleMessage : public classbase
 {
  public:
-        /** This class is pure virtual and must be inherited.
-         */
-        virtual char* Send() = 0;
+	/** This class is pure virtual and must be inherited.
+	 */
+	virtual char* Send() = 0;
 	virtual ~ModuleMessage() {};
 };
 
@@ -183,35 +188,35 @@ class ModuleMessage : public classbase
 class Request : public ModuleMessage
 {
  protected:
-        /** This member holds a pointer to arbitary data set by the emitter of the message
-         */
-        char* data;
-        /** This is a pointer to the sender of the message, which can be used to
-         * directly trigger events, or to create a reply.
-         */
-        Module* source;
-        /** The single destination of the Request
-         */
-        Module* dest;
+	/** This member holds a pointer to arbitary data set by the emitter of the message
+	 */
+	char* data;
+	/** This is a pointer to the sender of the message, which can be used to
+	 * directly trigger events, or to create a reply.
+	 */
+	Module* source;
+	/** The single destination of the Request
+	 */
+	Module* dest;
  public:
-        /** Create a new Request
-         */
-        Request(char* anydata, Module* src, Module* dst);
-        /** Fetch the Request data
-         */
-        char* GetData();
-        /** Fetch the request source
-         */
-        Module* GetSource();
-        /** Fetch the request destination (should be 'this' in the receiving module)
-         */
-        Module* GetDest();
-        /** Send the Request.
-         * Upon returning the result will be arbitary data returned by the module you
-         * sent the request to. It is up to your module to know what this data is and
-         * how to deal with it.
-         */
-        char* Send();
+	/** Create a new Request
+	 */
+	Request(char* anydata, Module* src, Module* dst);
+	/** Fetch the Request data
+	 */
+	char* GetData();
+	/** Fetch the request source
+	 */
+	Module* GetSource();
+	/** Fetch the request destination (should be 'this' in the receiving module)
+	 */
+	Module* GetDest();
+	/** Send the Request.
+	 * Upon returning the result will be arbitary data returned by the module you
+	 * sent the request to. It is up to your module to know what this data is and
+	 * how to deal with it.
+	 */
+	char* Send();
 };
 
 
@@ -223,37 +228,37 @@ class Request : public ModuleMessage
 class Event : public ModuleMessage
 {
  protected:
-        /** This member holds a pointer to arbitary data set by the emitter of the message
-         */
-        char* data;
-        /** This is a pointer to the sender of the message, which can be used to
-         * directly trigger events, or to create a reply.
-         */
-        Module* source;
-        /** The event identifier.
-         * This is arbitary text which should be used to distinguish
-         * one type of event from another.
-         */
-        std::string id;
+	/** This member holds a pointer to arbitary data set by the emitter of the message
+	 */
+	char* data;
+	/** This is a pointer to the sender of the message, which can be used to
+	 * directly trigger events, or to create a reply.
+	 */
+	Module* source;
+	/** The event identifier.
+	 * This is arbitary text which should be used to distinguish
+	 * one type of event from another.
+	 */
+	std::string id;
  public:
-        /** Create a new Event
-         */
-        Event(char* anydata, Module* src, std::string eventid);
-        /** Get the Event data
-         */
-        char* GetData();
-        /** Get the event Source
-         */
-        Module* GetSource();
-        /** Get the event ID.
-         * Use this to determine the event type for safe casting of the data
-         */
-        std::string GetEventID();
-        /** Send the Event.
-         * The return result of an Event::Send() will always be NULL as
-         * no replies are expected.
-         */
-        char* Send();
+	/** Create a new Event
+	 */
+	Event(char* anydata, Module* src, const std::string &eventid);
+	/** Get the Event data
+	 */
+	char* GetData();
+	/** Get the event Source
+	 */
+	Module* GetSource();
+	/** Get the event ID.
+	 * Use this to determine the event type for safe casting of the data
+	 */
+	std::string GetEventID();
+	/** Send the Event.
+	 * The return result of an Event::Send() will always be NULL as
+	 * no replies are expected.
+	 */
+	char* Send();
 };
 
 /** Holds an extended mode's details.
@@ -262,18 +267,54 @@ class Event : public ModuleMessage
 class ExtMode : public classbase
 {
  public:
-        char modechar;
-        int type;
-        bool needsoper;
-        int params_when_on;
-        int params_when_off;
-        bool list;
-        ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off) { };
+	char modechar;
+	int type;
+	bool needsoper;
+	int params_when_on;
+	int params_when_off;
+	bool list;
+	ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off), list(false) { };
 };
 
 
+/** This class can be used on its own to represent an exception, or derived to represent a module-specific exception.
+ * When a module whishes to abort, e.g. within a constructor, it should throw an exception using ModuleException or
+ * a class derived from ModuleException. If a module throws an exception during its constructor, the module will not
+ * 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
+{
+ private:
+	/** Holds the error message to be displayed
+	 */
+	std::string err;
+ public:
+	/** Default constructor, just uses the error mesage 'Module threw an exception'.
+	 */
+	ModuleException() : err("Module threw an exception") {}
+	/** This constructor can be used to specify an error message before throwing.
+	 */
+	ModuleException(std::string message) : err(message) {}
+	/** This destructor solves world hunger, cancels the world debt, and causes the world to end.
+	 * Actually no, it does nothing. Never mind.
+	 */
+	virtual ~ModuleException() {};
+	/** Returns the reason for the exception.
+	 * The module should probably put something informative here as the user will see this upon failure.
+	 */
+	virtual const char* GetReason()
+	{
+		return err.c_str();
+	}
+};
+
+/** Priority types which can be returned from Module::Prioritize()
+ */
 enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFORE, PRIORITY_AFTER };
 
+/** Implementation-specific flags which may be set in Module::Implements()
+ */
 enum Implementation {	I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUserJoin, I_OnUserPart, I_OnRehash, I_OnServerRaw, 
 			I_OnExtendedMode, 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,
@@ -285,12 +326,12 @@ enum Implementation {	I_OnUserConnect, I_OnUserQuit, I_OnUserDisconnect, I_OnUse
 			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_OnRawSocketAccept, I_OnRawSocketClose, I_OnRawSocketWrite, I_OnRawSocketRead, I_OnChangeLocalUserGECOS, I_OnUserRegister,
-			I_OnOperCompare, I_OnChannelDelete };
+			I_OnOperCompare, I_OnChannelDelete, I_OnPostOper, I_OnSyncOtherMetaData, I_OnSetAway, I_OnCancelAway };
 
 /** Base class for all InspIRCd modules
  *  This class is the base class for InspIRCd modules. All modules must inherit from this class,
  *  its methods will be called when irc server events occur. class inherited from module must be
- *  instantiated by the ModuleFactory class (see relevent section) for the plugin to be initialised.
+ *  instantiated by the ModuleFactory class (see relevent section) for the module to be initialised.
  */
 class Module : public classbase
 {
@@ -299,6 +340,7 @@ class Module : public classbase
 	/** Default constructor
 	 * Creates a module class.
 	 * @param Me An instance of the Server class which can be saved for future use
+	 * \exception ModuleException Throwing this class, or any class derived from ModuleException, causes loading of the module to abort.
 	 */
 	Module(Server* Me);
 
@@ -313,8 +355,39 @@ class Module : public classbase
 	 */
 	virtual Version GetVersion();
 
+	/** The Implements function specifies which methods a module should receive events for.
+	 * The char* parameter passed to this function contains a set of true or false values
+	 * (1 or 0) which indicate wether each function is implemented. You must use the Iimplementation
+	 * enum (documented elsewhere on this page) to mark functions as active. For example, to
+	 * receive events for OnUserJoin():
+	 *
+	 * Implements[I_OnUserJoin] = 1;
+	 *
+	 * @param The implement list
+	 */
 	virtual void Implements(char* Implements);
 
+	/** Used to set the 'priority' of a module (e.g. when it is called in relation to other modules.
+	 * Some modules prefer to be called before other modules, due to their design. For example, a
+	 * module which is expected to operate on complete information would expect to be placed last, so
+	 * that any other modules which wish to adjust that information would execute before it, to be sure
+	 * its information is correct. You can change your module's priority by returning one of:
+	 *
+	 * PRIORITY_FIRST - To place your module first in the list
+	 * 
+	 * PRIORITY_LAST - To place your module last in the list
+	 *
+	 * 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 Server::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
+	 * your module has a real need to reorder its priority, it should not implement this function,
+	 * as many modules changing their priorities can make the system redundant.
+	 */
 	virtual Priority Prioritize();
 
 	/** Called when a user connects.
@@ -330,7 +403,7 @@ class Module : public classbase
 	 * @param user The user who is quitting
 	 * @param message The user's quit message
 	 */
-	virtual void OnUserQuit(userrec* user, std::string message);
+	virtual void OnUserQuit(userrec* user, const std::string &message);
 
 	/** Called whenever a user's socket is closed.
 	 * The details of the exiting user are available to you in the parameter userrec *user
@@ -360,7 +433,7 @@ class Module : public classbase
 	 * @param channel The channel being parted
 	 * @param partmessage The part message, or an empty string
 	 */
-	virtual void OnUserPart(userrec* user, chanrec* channel, std::string partmessage);
+	virtual void OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage);
 
 	/** Called on rehash.
 	 * This method is called prior to a /REHASH or when a SIGHUP is received from the operating
@@ -369,7 +442,7 @@ class Module : public classbase
 	 * receiving the event can decide if this parameter has any relevence to it.
 	 * @param parameter The (optional) parameter given to REHASH from the user.
 	 */
- 	virtual void OnRehash(std::string parameter);
+ 	virtual void OnRehash(const std::string &parameter);
 
 	/** 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
@@ -419,7 +492,7 @@ class Module : public classbase
 	 */
 	virtual int OnUserPreJoin(userrec* user, chanrec* chan, const char* cname);
 	
-        /** Called whenever a user is about to be kicked.
+	/** Called whenever a user is about to be kicked.
          * Returning a value of 1 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.
@@ -427,9 +500,9 @@ class Module : public classbase
 	 * @param user The user being kicked
 	 * @param chan The channel the user is being kicked from
 	 * @param reason The kick reason
-	 * @return 1 to prevent the kick, 0 to allow it
+	 * @return 1 to prevent the kick, 0 to continue normally, -1 to explicitly allow the kick regardless of normal operation
          */
-	virtual int OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason);
+	virtual int OnUserPreKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason);
 
 	/** Called whenever a user is kicked.
 	 * If this method is called, the kick is already underway and cannot be prevented, so
@@ -439,7 +512,7 @@ class Module : public classbase
 	 * @param chan The channel the user is being kicked from
 	 * @param reason The kick reason
 	 */
-	virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason);
+	virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason);
 
 	/** Called whenever a user opers locally.
 	 * The userrec will contain the oper mode 'o' as this function is called after any modifications
@@ -447,7 +520,16 @@ class Module : public classbase
 	 * @param user The user who is opering up
 	 * @param opertype The opers type name
 	 */
-	virtual void OnOper(userrec* user, std::string opertype);
+	virtual void OnOper(userrec* user, const std::string &opertype);
+
+	/** Called after a user opers locally.
+	 * This is identical to Module::OnOper(), except it is called after OnOper so that other modules
+	 * can be gauranteed to already have processed the oper-up, for example m_spanningtree has sent
+	 * out the OPERTYPE, etc.
+	 * @param user The user who is opering up
+	 * @param opertype The opers type name
+	 */
+	virtual void OnPostOper(userrec* user, const std::string &opertype);
 	
 	/** Called whenever a user types /INFO.
 	 * The userrec will contain the information of the user who typed the command. Modules may use this
@@ -500,9 +582,10 @@ class Module : public classbase
 	 * @param dest The target of the message (chanrec* or userrec*)
 	 * @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.
 	 * @return 1 to deny the NOTICE, 0 to allow it
 	 */
-	virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text);
+	virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text,char status);
 
 	/** 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
@@ -518,9 +601,10 @@ class Module : public classbase
 	 * @param dest The target of the message (chanrec* or userrec*)
 	 * @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.
 	 * @return 1 to deny the NOTICE, 0 to allow it
 	 */
-	virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text);
+	virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text,char status);
 	
 	/** 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
@@ -532,7 +616,7 @@ class Module : public classbase
 	 * @param newnick Their new nickname
 	 * @return 1 to deny the change, 0 to allow
 	 */
-	virtual int OnUserPreNick(userrec* user, std::string newnick);
+	virtual int OnUserPreNick(userrec* user, const std::string &newnick);
 
 	/** Called after any PRIVMSG sent from a user.
 	 * The dest variable contains a userrec* if target_type is TYPE_USER and a chanrec*
@@ -541,18 +625,20 @@ class Module : public classbase
 	 * @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. PRIVMSG @#chan has status== '@', 0 to send to everyone.
 	 */
-	virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text);
+	virtual void OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status);
 
-        /** Called after any NOTICE sent from a user.
+	/** Called after any NOTICE sent from a user.
 	 * The dest variable contains a userrec* if target_type is TYPE_USER and a chanrec*
 	 * 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.
 	 */
-	virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text);
+	virtual void OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status);
 
 	/** Called after every MODE command sent from a user
 	 * The dest variable contains a userrec* if target_type is TYPE_USER and a chanrec*
@@ -563,7 +649,7 @@ class Module : public classbase
 	 * @param target_type The type of target (TYPE_USER or TYPE_CHANNEL)
 	 * @param text The actual modes and their parameters if any
 	 */
-	virtual void OnMode(userrec* user, void* dest, int target_type, std::string text);
+	virtual void OnMode(userrec* user, void* dest, int target_type, const std::string &text);
 
 	/** Allows modules to alter or create server descriptions
 	 * Whenever a module requires a server description, for example for display in
@@ -573,7 +659,7 @@ class Module : public classbase
 	 * @param servername The servername being searched for
 	 * @param description Alterable server description for this server
 	 */
-	virtual void OnGetServerDescription(std::string servername,std::string &description);
+	virtual void OnGetServerDescription(const std::string &servername,std::string &description);
 
 	/** Allows modules to synchronize data which relates to users during a netburst.
 	 * When this function is called, it will be called from the module which implements
@@ -617,7 +703,7 @@ class Module : public classbase
 	 * @param opaque An opaque pointer set by the protocol module, should not be modified!
 	 * @param extname The extensions name which is being searched for
 	 */
-	virtual void OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, std::string extname);
+	virtual void OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, const std::string &extname);
 
 	/* Allows modules to syncronize metadata related to users over the network during a netburst.
 	 * Whenever the linking module wants to send out data, but doesnt know what the data
@@ -630,7 +716,18 @@ class Module : public classbase
 	 * @param opaque An opaque pointer set by the protocol module, should not be modified!
 	 * @param extname The extensions name which is being searched for
 	 */
-	virtual void OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, std::string extname);
+	virtual void OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, const std::string &extname);
+
+	/* Allows modules to syncronize metadata not related to users or channels, over the network during a netburst.
+	 * Whenever the linking module wants to send out data, but doesnt know what the data
+	 * represents (e.g. it is Extensible metadata, added to a userrec or chanrec by a module) then
+	 * this method is called. You should use the ProtoSendMetaData function after you've
+	 * correctly decided how the data should be represented, to send the metadata on its way if
+	 * if it belongs to your module.
+	 * @param proto A pointer to the module handling network protocol
+	 * @param opaque An opaque pointer set by the protocol module, should not be modified!
+	 */
+	virtual void OnSyncOtherMetaData(Module* proto, void* opaque);
 
 	/** Allows module data, sent via ProtoSendMetaData, to be decoded again by a receiving module.
 	 * Please see src/modules/m_swhois.cpp for a working example of how to use this method call.
@@ -639,7 +736,7 @@ class Module : public classbase
 	 * @param extname The extension name which is being sent
 	 * @param extdata The extension data, encoded at the other end by an identical module through OnSyncChannelMetaData or OnSyncUserMetaData
 	 */
-	virtual void OnDecodeMetaData(int target_type, void* target, std::string extname, std::string extdata);
+	virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata);
 
 	/** Implemented by modules which provide the ability to link servers.
 	 * These modules will implement this method, which allows transparent sending of servermodes
@@ -654,7 +751,7 @@ class Module : public classbase
 	 * @param target The chanrec* or userrec* that modes should be sent for
 	 * @param modeline The modes and parameters to be sent
 	 */
-	virtual void ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline);
+	virtual void ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline);
 
 	/** Implemented by modules which provide the ability to link servers.
 	 * These modules will implement this method, which allows metadata (extra data added to
@@ -670,27 +767,27 @@ class Module : public classbase
 	 * @param extname The extension name to send metadata for
 	 * @param extdata Encoded data for this extension name, which will be encoded at the oppsite end by an identical module using OnDecodeMetaData
 	 */
-	virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata);
+	virtual void ProtoSendMetaData(void* opaque, int target_type, void* 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(userrec* user, std::string text);
+	virtual void OnWallops(userrec* 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
 	 * @param newhost The new hostname being set
 	 */
-	virtual void OnChangeHost(userrec* user, std::string newhost);
+	virtual void OnChangeHost(userrec* user, const std::string &newhost);
 
 	/** Called whenever a user's GECOS (realname) is changed.
 	 * This event triggers after the name has been set.
 	 * @param user The user who's GECOS is being changed
 	 * @param gecos The new GECOS being set on the user
 	 */
-	virtual void OnChangeName(userrec* user, std::string gecos);
+	virtual void OnChangeName(userrec* user, const std::string &gecos);
 
 	/** Called whenever a gline is added by a local user.
 	 * This method is triggered after the line is added.
@@ -699,7 +796,7 @@ class Module : public classbase
 	 * @param reason The reason text to be displayed
 	 * @param hostmask The hostmask to add
 	 */
-	virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask);
+	virtual void OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask);
 
 	/** Called whenever a zline is added by a local user.
 	 * This method is triggered after the line is added.
@@ -708,7 +805,7 @@ class Module : public classbase
          * @param reason The reason text to be displayed
          * @param ipmask The hostmask to add
 	 */
-	virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask);
+	virtual void OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask);
 
 	/** Called whenever a kline is added by a local user.
 	 * This method is triggered after the line is added.
@@ -717,7 +814,7 @@ class Module : public classbase
          * @param reason The reason text to be displayed
          * @param hostmask The hostmask to add
 	 */
-	virtual void OnAddKLine(long duration, userrec* source, std::string reason, std::string hostmask);
+	virtual void OnAddKLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask);
 
 	/** Called whenever a qline is added by a local user.
 	 * This method is triggered after the line is added.
@@ -726,7 +823,7 @@ class Module : public classbase
          * @param reason The reason text to be displayed
          * @param nickmask The hostmask to add
 	 */
-	virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask);
+	virtual void OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask);
 
 	/** Called whenever a eline is added by a local user.
 	 * This method is triggered after the line is added.
@@ -735,42 +832,42 @@ class Module : public classbase
          * @param reason The reason text to be displayed
          * @param hostmask The hostmask to add
 	 */
-	virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask);
+	virtual void OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask);
 
 	/** Called whenever a gline is deleted.
 	 * This method is triggered after the line is deleted.
          * @param source The user removing the line
          * @param hostmask The hostmask to delete
 	 */
-	virtual void OnDelGLine(userrec* source, std::string hostmask);
+	virtual void OnDelGLine(userrec* source, const std::string &hostmask);
 
 	/** Called whenever a zline is deleted.
 	 * This method is triggered after the line is deleted.
          * @param source The user removing the line
          * @param hostmask The hostmask to delete
 	 */
-	virtual void OnDelZLine(userrec* source, std::string ipmask);
+	virtual void OnDelZLine(userrec* source, const std::string &ipmask);
 
 	/** Called whenever a kline is deleted.
 	 * This method is triggered after the line is deleted.
          * @param source The user removing the line
          * @param hostmask The hostmask to delete
 	 */
-	virtual void OnDelKLine(userrec* source, std::string hostmask);
+	virtual void OnDelKLine(userrec* source, const std::string &hostmask);
 	
 	/** Called whenever a qline is deleted.
 	 * This method is triggered after the line is deleted.
          * @param source The user removing the line
          * @param hostmask The hostmask to delete
 	 */
-	virtual void OnDelQLine(userrec* source, std::string nickmask);
+	virtual void OnDelQLine(userrec* source, const std::string &nickmask);
 
 	/** Called whenever a eline is deleted.
 	 * This method is triggered after the line is deleted.
          * @param source The user removing the line
          * @param hostmask The hostmask to delete
 	 */
-	virtual void OnDelELine(userrec* source, std::string hostmask);
+	virtual void OnDelELine(userrec* source, const std::string &hostmask);
 
 	/** Called before your module is unloaded to clean up Extensibles.
 	 * This method is called once for every user and channel on the network,
@@ -792,7 +889,7 @@ class Module : public classbase
 	 * @param user The user changing their nick
 	 * @param oldnick The old nickname of the user before the nickchange
          */
-	virtual void OnUserPostNick(userrec* user, std::string oldnick);
+	virtual void OnUserPostNick(userrec* user, const std::string &oldnick);
 
 	/** Called before an action which requires a channel privilage check.
 	 * This function is called before many functions which check a users status on a channel, for example
@@ -840,14 +937,14 @@ class Module : public classbase
 	 * @param reason The kill reason
 	 * @return 1 to prevent the kill, 0 to allow
 	 */
-	virtual int OnKill(userrec* source, userrec* dest, std::string reason);
+	virtual int OnKill(userrec* source, userrec* 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
 	 */
-	virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason);
+	virtual void OnRemoteKill(userrec* source, userrec* dest, const std::string &reason);
 
 	/** Called whenever a module is loaded.
 	 * mod will contain a pointer to the module, and string will contain its name,
@@ -861,7 +958,7 @@ class Module : public classbase
 	 * @param mod A pointer to the new module
 	 * @param name The new module's filename
 	 */
-	virtual void OnLoadModule(Module* mod,std::string name);
+	virtual void OnLoadModule(Module* mod,const std::string &name);
 
 	/** Called whenever a module is unloaded.
          * mod will contain a pointer to the module, and string will contain its name,
@@ -875,7 +972,7 @@ class Module : public classbase
 	 * @param mod Pointer to the module being unloaded (still valid)
 	 * @param name The filename of the module being unloaded
          */
-	virtual void OnUnloadModule(Module* mod,std::string name);
+	virtual void OnUnloadModule(Module* mod,const std::string &name);
 
 	/** Called once every five seconds for background processing.
 	 * This timer can be used to control timed features. Its period is not accurate
@@ -913,7 +1010,7 @@ class Module : public classbase
 	 * @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.
 	 * @return 1 to block the command, 0 to allow
 	 */
-	virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated);
+	virtual int OnPreCommand(const std::string &command, char **parameters, int pcnt, userrec *user, bool validated);
 
 	/** 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
@@ -949,7 +1046,7 @@ class Module : public classbase
 	 * @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, std::string param, bool adding, int pcnt);
+	virtual int OnRawMode(userrec* user, chanrec* chan, char mode, const std::string &param, bool adding, int pcnt);
 
 	/** 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
@@ -961,7 +1058,7 @@ class Module : public classbase
 	 */
 	virtual int OnCheckInvite(userrec* user, chanrec* chan);
 
-        /** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
+	/** 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.
@@ -970,9 +1067,9 @@ class Module : public classbase
 	 * @param chan The channel being joined
 	 * @return 1 to explicitly allow the join, 0 to proceed as normal
          */
-	virtual int OnCheckKey(userrec* user, chanrec* chan, std::string keygiven);
+	virtual int OnCheckKey(userrec* user, chanrec* chan, const std::string &keygiven);
 
-        /** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
+	/** 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.
@@ -982,7 +1079,7 @@ class Module : public classbase
          */
 	virtual int OnCheckLimit(userrec* user, chanrec* chan);
 
-        /** Called whenever a user joins a channel, to determine if banlist checks should go ahead or not.
+	/** 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.
@@ -1006,7 +1103,7 @@ class Module : public classbase
 	 * @param newhost The new hostname
 	 * @return 1 to deny the host change, 0 to allow
 	 */
-	virtual int OnChangeLocalUserHost(userrec* user, std::string newhost);
+	virtual int OnChangeLocalUserHost(userrec* 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.
@@ -1014,7 +1111,7 @@ class Module : public classbase
 	 * @param newhost The new GECOS
 	 * @return 1 to deny the GECOS change, 0 to allow
 	 */
-	virtual int OnChangeLocalUserGECOS(userrec* user, std::string newhost); 
+	virtual int OnChangeLocalUserGECOS(userrec* user, const std::string &newhost); 
 
 	/** Called whenever a topic is changed by a local user.
 	 * Return 1 to deny the topic change, or 0 to allow it.
@@ -1023,7 +1120,7 @@ class Module : public classbase
 	 * @param topic The actual topic text
 	 * @param 1 to block the topic change, 0 to allow
 	 */
-	virtual int OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic);
+	virtual int OnLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic);
 
 	/** Called whenever a local topic has been changed.
 	 * To block topic changes you must use OnLocalTopicChange instead.
@@ -1031,7 +1128,7 @@ class Module : public classbase
 	 * @param chan The channels who's topic is being changed
 	 * @param topic The actual topic text
 	 */
-	virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic);
+	virtual void OnPostLocalTopicChange(userrec* user, chanrec* 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
@@ -1059,7 +1156,7 @@ class Module : public classbase
 	 * @param input The password entered
 	 * @return 1 to match the passwords, 0 to do nothing
 	 */
-	virtual int OnOperCompare(std::string password, std::string input);
+	virtual int OnOperCompare(const std::string &password, const 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
@@ -1083,7 +1180,7 @@ class Module : public classbase
 	 * @param banmask The ban mask being added
 	 * @return 1 to block the ban, 0 to continue as normal
 	 */
-	virtual int OnAddBan(userrec* source, chanrec* channel,std::string banmask);
+	virtual int OnAddBan(userrec* source, chanrec* 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.
@@ -1092,7 +1189,7 @@ class Module : public classbase
 	 * @param banmask The ban mask being deleted
 	 * @return 1 to block the unban, 0 to continue as normal
 	 */
-	virtual int OnDelBan(userrec* source, chanrec* channel,std::string banmask);
+	virtual int OnDelBan(userrec* source, chanrec* channel,const 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
@@ -1103,7 +1200,7 @@ class Module : public classbase
 	 * @param ip The IP address of the connecting user
 	 * @param localport The local port number the user connected to
 	 */
-	virtual void OnRawSocketAccept(int fd, std::string ip, int localport);
+	virtual void OnRawSocketAccept(int fd, const 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
@@ -1139,6 +1236,16 @@ class Module : public classbase
 	 * @return nonzero if the event was handled, in which case readresult must be valid on exit
 	 */
 	virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult);
+
+	/** Called whenever a user sets away.
+	 * This method has no parameter for the away message, as it is available in the
+	 * user record as userrec::awaymsg.
+	 */
+	virtual void OnSetAway(userrec* user);
+
+	/** Called when a user cancels their away state.
+	 */
+	virtual void OnCancelAway(userrec* user);
 };
 
 
@@ -1154,10 +1261,12 @@ class Server : public classbase
 	 * Creates a Server object.
 	 */
 	Server();
+
 	/** Default destructor.
 	 * Destroys a Server object.
 	 */
 	virtual ~Server();
+
 	/** Obtains a pointer to the server's ServerConfig object.
 	 * The ServerConfig object contains most of the configuration data
 	 * of the IRC server, as read from the config file by the core.
@@ -1167,52 +1276,61 @@ class Server : public classbase
 	/** 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'.
+	 * 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(std::string modulename);
+	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'.
+	 * 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(std::string modulename);
+	long PriorityAfter(const std::string &modulename);
 	
 	/** Sends text to all opers.
 	 * This method sends a server notice to all opers with the usermode +s.
 	 */
-	virtual void SendOpers(std::string s);
+	virtual void SendOpers(const std::string &s);
+
 	/** Returns the version string of this server
 	 */
 	std::string GetVersion();
+
 	/** 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);
+	virtual void Log(int level, const 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);
+	virtual void Send(int Socket, const 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);
+	virtual void SendServ(int Socket, const std::string &s);
+
 	/** Writes text to a channel, but from a server, including all.
 	 * This can be used to send server notices to a group of users.
 	 */
-	virtual void SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text);
+	virtual void SendChannelServerNotice(const std::string &ServName, chanrec* Channel, const std::string &text);
+
 	/** 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);
+	virtual void SendFrom(int Socket, userrec* User, const 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)
@@ -1227,19 +1345,22 @@ class Server : public classbase
 	 *
 	 * Which is useful for numerics and server notices to single users, etc.
 	 */
-	virtual void SendTo(userrec* Source, userrec* Dest, std::string s);
+	virtual void SendTo(userrec* Source, userrec* Dest, const 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);
+	virtual void SendChannel(userrec* User, chanrec* Channel, const 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
@@ -1247,57 +1368,68 @@ class Server : public classbase
 	 * 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);
+	virtual void SendCommon(userrec* User, const 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);
+	virtual void SendWallops(userrec* User, const std::string &text);
 
 	/** Returns true if a nick is valid.
 	 * Nicks for unregistered connections will return false.
 	 */
-	virtual bool IsNick(std::string nick);
+	virtual bool IsNick(const 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);
+
+	/** Adds an InspTimer which will trigger at a future time
+	 */
+	virtual void AddTimer(InspTimer* T);
+
 	/** 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);
+	virtual userrec* FindNick(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.
 	 */
 	virtual userrec* FindDescriptor(int socket);
+
 	/** 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);
+	virtual chanrec* FindChannel(const 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 server description string of the local server
 	 */
 	virtual std::string GetServerDescription();
+
 	/** 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
@@ -1395,28 +1527,28 @@ class Server : public classbase
   	 * 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);
+  	virtual void SendToModeMask(const std::string &modes, int flags, const 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);
+	virtual chanrec* JoinUserToChannel(userrec* user, const std::string &cname, const 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);
+	virtual chanrec* PartUserFromChannel(userrec* user, const std::string &cname, const 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);
+	virtual void ChangeUserNick(userrec* user, const 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
@@ -1428,15 +1560,22 @@ class Server : public classbase
 	 * 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);
+	virtual void QuitUser(userrec* user, const std::string &reason);
 
-	virtual void KickUser(userrec* source, userrec* target, chanrec* chan, std::string reason);
+	/** Makes a user kick another user, with the specified reason.
+	 * If source is NULL, the server will peform the kick.
+	 * @param The person or server (if NULL) performing the KICK
+	 * @param target The person being kicked
+	 * @param chan The channel to kick from
+	 * @param reason The kick reason
+	 */
+	virtual void KickUser(userrec* source, userrec* target, chanrec* chan, const 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);
+	virtual 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,
@@ -1448,34 +1587,37 @@ class Server : public classbase
 	 * 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
 	 */
-	virtual void CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user);
+	virtual bool CallCommandHandler(const std::string &commandname, char** parameters, int pcnt, userrec* user);
 
-	virtual bool IsValidModuleCommand(std::string commandname, 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)
+	 */
+	virtual bool IsValidModuleCommand(const std::string &commandname, 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);
+	virtual void ChangeHost(userrec* user, const 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);
+	virtual void ChangeGECOS(userrec* user, const 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.
+	 * no channel operators for that channel on the ulined server, amongst other things.
 	 */
-	virtual bool IsUlined(std::string server);
+	virtual bool IsUlined(const 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.
@@ -1488,15 +1630,15 @@ class Server : public classbase
 	 * remain until it is restored with a valid file descriptor, or is removed from IRC by an operator
 	 * After this call, the pointer to user will be invalid.
 	 */
-	virtual bool UserToPseudo(userrec* user,std::string message);
+	virtual bool UserToPseudo(userrec* user, const std::string &message);
 
 	/** This user takes one user, and switches their file descriptor with another user, so that one user
 	 * "becomes" the other. The user in 'alive' is booted off the server with the given message. The user
-	 * referred to by 'zombie' should have previously been locked with Server::ZombifyUser, otherwise
+	 * referred to by 'zombie' should have previously been locked with Server::UserToPseudo, otherwise
 	 * stale sockets and file descriptor leaks can occur. After this call, the pointer to alive will be
 	 * invalid, and the pointer to zombie will be equivalent in effect to the old pointer to alive.
 	 */
-	virtual bool PseudoToUser(userrec* alive,userrec* zombie,std::string message);
+	virtual bool PseudoToUser(userrec* alive, userrec* zombie, const std::string &message);
 
 	/** 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.
@@ -1505,80 +1647,80 @@ class Server : public classbase
 	 * to indicate who or what sent the data, usually this is the nickname of a person, or a server
 	 * name.
 	 */
-	virtual void AddGLine(long duration, std::string source, std::string reason, std::string hostmask);
+	virtual 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.
-         */
-	virtual void AddQLine(long duration, std::string source, std::string reason, 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.
-         */
-	virtual void AddZLine(long duration, std::string source, std::string reason, 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.
-         */
-	virtual void AddKLine(long duration, std::string source, std::string reason, 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.
-         */
-	virtual void AddELine(long duration, std::string source, std::string reason, 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.
+	 */
+	virtual void AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname);
 
-	/** Deletes a G-Line from all servers on the mesh
+	/** 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.
 	 */
-	virtual bool DelGLine(std::string hostmask);
+	virtual void AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr);
 
-	/** Deletes a Q-Line from all servers on the mesh
+	/** 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.
 	 */
-	virtual bool DelQLine(std::string nickname);
+	virtual void AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
 
-	/** Deletes a Z-Line from all servers on the mesh
+	/** 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.
+	 */
+	virtual void AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask);
+
+	/** Deletes a G-Line from all servers
+	 */
+	virtual bool DelGLine(const std::string &hostmask);
+
+	/** Deletes a Q-Line from all servers
+	 */
+	virtual bool DelQLine(const std::string &nickname);
+
+	/** Deletes a Z-Line from all servers
 	 */
-	virtual bool DelZLine(std::string ipaddr);
+	virtual bool DelZLine(const std::string &ipaddr);
 
 	/** Deletes a local K-Line
 	 */
-	virtual bool DelKLine(std::string hostmask);
+	virtual bool DelKLine(const std::string &hostmask);
 
 	/** Deletes a local E-Line
 	 */
-	virtual bool DelELine(std::string hostmask);
+	virtual 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.
 	 */
-	virtual long CalcDuration(std::string duration);
+	virtual long CalcDuration(const std::string &duration);
 
 	/** Returns true if a nick!ident@host string is correctly formatted, false if otherwise.
 	 */
-	virtual bool IsValidMask(std::string mask);
+	virtual 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.
 	 */
-	virtual Module* FindModule(std::string name);
+	virtual Module* FindModule(const std::string &name);
 
 	/** Adds a class derived from InspSocket to the server's socket engine.
 	 */
@@ -1592,7 +1734,28 @@ class Server : public classbase
 	 */
 	virtual 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!
+	 */
 	virtual void RehashServer();
+
+	/** This method returns the total number of channels on the network.
+	 */
+	virtual 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.
+	 */
+	virtual 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);
 };
 
 
@@ -1616,10 +1779,11 @@ class ConfigReader : public classbase
 	 * core is changed). It will contain a pointer to the configuration file data with unneeded data
 	 * (such as comments) stripped from it.
 	 */
-	std::stringstream *cache;
-	std::stringstream *errorlog;
+	ConfigDataHash* data;
+	std::ostringstream* errorlog;;
 	/** Used to store errors
 	 */
+	bool privatehash; // If we're using our own config data hash or not.
 	bool readerror;
 	long error;
 	
@@ -1632,7 +1796,7 @@ class ConfigReader : public classbase
 	/** Overloaded constructor.
 	 * This constructor initialises the ConfigReader class to read a user-specified config file
 	 */
-	ConfigReader(std::string filename);	// read a module-specific config
+	ConfigReader(const std::string &filename);	// read a module-specific config
 	/** Default destructor.
 	 * This method destroys the ConfigReader class.
 	 */
@@ -1641,13 +1805,13 @@ class ConfigReader : public classbase
 	 * 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(std::string tag, std::string name, int index);
+	std::string ReadValue(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.
 	 */
-	bool ReadFlag(std::string tag, std::string name, int index);
+	bool ReadFlag(const std::string &tag, const std::string &name, 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
@@ -1656,7 +1820,7 @@ class ConfigReader : public classbase
 	 * If a signed number is placed into a tag which is specified unsigned, 0 will be returned and GetError()
 	 * will return CONF_NOT_UNSIGNED
 	 */
-	long ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned);
+	long ReadInteger(const std::string &tag, const std::string &name, 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.
@@ -1668,7 +1832,7 @@ class ConfigReader : public classbase
 	 * used with the index value of ConfigReader::ReadValue to loop through all copies of a
 	 * multiple instance tag.
 	 */
-	int Enumerate(std::string tag);
+	int Enumerate(const std::string &tag);
 	/** Returns true if a config file is valid.
 	 * This method is partially implemented and will only return false if the config
 	 * file does not exist or could not be opened.
@@ -1687,7 +1851,7 @@ class ConfigReader : public classbase
 	 * function would return 2. Spaces and newlines both qualify as valid seperators
 	 * between values.
 	 */
-	int EnumerateValues(std::string tag, int index);
+	int EnumerateValues(const std::string &tag, int index);
 };
 
 
@@ -1699,7 +1863,9 @@ class ConfigReader : public classbase
  */
 class FileReader : public classbase
 {
- file_cache fc;
+	/** The file contents
+	 */
+	file_cache fc;
  public:
 	 /** Default constructor.
 	  * This method does not load any file into memory, you must use the LoadFile method
@@ -1712,7 +1878,7 @@ class FileReader : public classbase
 	  * and other methods to be called. If the file could not be loaded, FileReader::FileSize
 	  * returns 0.
 	  */
-	 FileReader(std::string filename);
+	 FileReader(const std::string &filename);
 
 	 /** Default destructor.
 	  * This deletes the memory allocated to the file.
@@ -1724,7 +1890,7 @@ class FileReader : public classbase
 	  * and other methods to be called. If the file could not be loaded, FileReader::FileSize
 	  * returns 0.
 	  */
-	 void LoadFile(std::string filename);
+	 void LoadFile(const std::string &filename);
 
 	 /** Returns true if the file exists
 	  * This function will return false if the file could not be opened.
@@ -1766,6 +1932,8 @@ class ModuleFactory : public classbase
 
 
 typedef DLLFactory<ModuleFactory> ircd_module;
+typedef std::vector<Module*> ModuleList;
+typedef std::vector<ircd_module*> FactoryList;
 
 bool ModeDefined(char c, int i);
 bool ModeDefinedOper(char c, int i);