diff --git a/GNUmakefile b/GNUmakefile
index abc2db2..d48d663 100644
--- a/GNUmakefile
+++ b/GNUmakefile
@@ -152,6 +152,7 @@ libuhub_SOURCES := \
 		src/core/plugincallback.c \
 		src/core/plugininvoke.c \
 		src/core/pluginloader.c \
+		src/core/pluginucmd.c \
 		src/network/backend.c \
 		src/network/connection.c \
 		src/network/epoll.c \
@@ -236,6 +237,9 @@ plugin_chat_only_TARGET  := mod_chat_only.so
 plugin_topic_SOURCES := src/plugins/mod_topic.c
 plugin_topic_TARGET  := mod_topic.so
 
+plugin_ucmd_SOURCES := src/plugins/mod_ucmd.c
+plugin_ucmd_TARGET  := mod_ucmd.so
+
 # Source to objects
 libuhub_OBJECTS       := $(libuhub_SOURCES:.c=.o)
 libutils_OBJECTS      := $(libutils_SOURCES:.c=.o)
@@ -255,7 +259,8 @@ all_plugins := \
 		$(plugin_welcome_TARGET) \
 		$(plugin_chat_history_TARGET) \
 		$(plugin_chat_only_TARGET) \
-		$(plugin_topic_TARGET)
+		$(plugin_topic_TARGET) \
+		$(plugin_ucmd_TARGET)
 
 all_OBJECTS := \
 		$(libuhub_OBJECTS) \
@@ -314,6 +319,8 @@ $(plugin_welcome_TARGET): $(plugin_welcome_SOURCES) $(libutils_OBJECTS)
 $(plugin_topic_TARGET): $(plugin_topic_SOURCES) $(libutils_OBJECTS)
 	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
 
+$(plugin_ucmd_TARGET): $(plugin_ucmd_SOURCES) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
 
 $(adcrush_BINARY): $(adcrush_OBJECTS) $(libuhub_OBJECTS) $(libutils_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
 	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
@@ -364,6 +371,7 @@ install: all
 	@if [ ! -f $(UHUB_CONF_DIR)/uhub.conf ]; then cp doc/uhub.conf $(UHUB_CONF_DIR); fi
 	@if [ ! -f $(UHUB_CONF_DIR)/rules.txt ]; then cp doc/rules.txt $(UHUB_CONF_DIR); fi
 	@if [ ! -f $(UHUB_CONF_DIR)/plugins.conf ]; then cp doc/plugins.conf $(UHUB_CONF_DIR); fi
+	@if [ ! -f $(UHUB_CONF_DIR)/ucmd.conf ]; then cp doc/ucmd.conf $(UHUB_CONF_DIR); fi
 	@if [ ! -d $(UHUB_MOD_DIR) ]; then echo Creating $(UHUB_MOD_DIR); mkdir -p $(UHUB_MOD_DIR); fi
 	@cp -f mod_*.so $(UHUB_MOD_DIR)
 	@touch $(UHUB_CONF_DIR)/motd.txt
diff --git a/doc/plugins.conf b/doc/plugins.conf
index e45f35c..ff15da7 100644
--- a/doc/plugins.conf
+++ b/doc/plugins.conf
@@ -60,3 +60,15 @@ plugin /var/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rul
 # history_connect: the number of chat history messages to send when users connect (0 = do not send any history)
 plugin /var/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
 
+# A plugin to send user commands. These are custom commands which are shown in
+# the right-click menu of the users client software and allows easy usage of
+# hub commands.
+#
+# Parameters:
+# file: the file where the list of user commands is stored.
+#
+# NB. Any changes to the commands (if you either change the file location, or
+# edit the file itself) will be picked up when you reload the configuration.
+# However, the menu that users see is not auto-refreshed i.e., users will not
+# see the changes to the commands until they disconnect and reconnect.
+plugin /var/lib/uhub/mod_ucmd.so "file=/etc/uhub/ucmd.conf"
diff --git a/doc/ucmd.conf b/doc/ucmd.conf
new file mode 100644
index 0000000..1289a39
--- /dev/null
+++ b/doc/ucmd.conf
@@ -0,0 +1,168 @@
+# User command configuration for standard uhub commands.
+#
+# Each command contains at least two lines: the first defines the command name
+# and required credentials, and the following lines define the action(s) taken
+# by the client when the user selects the command.
+#
+# Leading and trailing whitespace is trimmed from each line. Commented lines
+# and blank lines are ignored. All keywords in the file are not case sensitive.
+#
+# Command definition
+# ------------------
+#
+# The first line of a command defines the credentials required, the context(s)
+# that the command should be shown in, and the name it is displayed as in the
+# user command menu. It takes the following format:
+#
+# <credential level required> <list of contexts> <command name>
+#
+# The credential level is the minimum credentials required to access the
+# command. Anybody with this level or greater will be able to see it. The
+# levels are: 0 = none, 1 = bot, 2 = unregistered user, 3 = registered user,
+# 4 = operator, 5 = super (not used currently), 6 = link (not used currently),
+# 7 = admin.
+#
+# The contexts are a comma separated list which tell the client where to
+# display the command. Possible values are:
+#
+# * hub: in a general right-click menu for the hub
+# * user: in a right-click menu in the user list
+# * search: in a search results window
+# * filelist: in a file list window
+# * all: all of the above
+#
+# The command name is what is displayed in the client menu and *must* be unique
+# as the clients use it as an identifier.
+#
+# Nested menus can be created by adding backslashes (\) to the name, for example,
+# User actions\Kick. NB. the ADC UCMD extension specifies a forward slash (/),
+# but all clients appear to use the backslash as per the old NMDC protocol, so
+# the backslash is recommended.
+#
+# Actions
+# -------
+#
+# Following the command definition, one or more lines are given to specify the
+# action or actions the client should take when the user selects the command.
+# The order of the actions in this file is the order the client will perform
+# them. There are three actions available, each of which can be used multiple
+# times in a command:
+#
+# Chat <me> <message>
+# Sends a message in the main chat window. The <me> parameter is 0 or 1, with 1
+# meaning it is formatted as a /me <action> style message by clients.
+#
+# PM <echo> <target> <message>
+# Sends a private message. If you have set up a user with a reserved SID, you
+# can specify the SID the target. Alternatively, you can use the word Selected
+# as the target to specify the currently selected user (this won't work in the
+# hub context, as there is no user selected there). The <echo> parameter can be
+# 0 or 1, with 1 specifying the message should be echoed to the sending user as
+# well.
+#
+# Separator
+# Specifies that the entry should be displayed as a separator instead of text,
+# meaning there is no 'real' action to run. If this is given, any other actions
+# will be ignored. A unique name is still required for each separator.
+#
+# Substitutions
+# -------------
+#
+# The client can substitute pieces of text into the actions before it sends
+# them. The most useful ones are %[myNI], which is replaced with the nickname
+# of the user performing the action, and %[userNI], which is replaced with the
+# nickname of the user that was selected in a user list when the command was
+# run. The %[userNI] substitution does not work in the hub context, as there is
+# no user selected there.
+#
+# You can also prompt the user for a piece of text with the substitution
+# %[line:<message shown in prompt>]. If the same prompt is used multiple times
+# within a command (whether in the same or different actions), the user is only
+# asked once and the response is used for all instances of the prompt.
+#
+# For a full list of available substitutions and the contexts they work in, see
+# the specification for the UCMD extension, currently available at
+# http://adc.sourceforge.net/versions/ADC-EXT-1.0.6.html#_ucmd_user_commands
+
+
+# Basic commands available to all users.
+# These don't strictly belong in the user context, but it is often a good idea
+# to put them there because the user list is a common place to right-click and
+# people probably expect to see them there.
+0 hub,user Show my IP
+Chat 0 !myip
+0 hub,user Hub uptime
+Chat 0 !uptime
+0 hub,user Hub version
+Chat 0 !version
+0 hub,user BasicSeparator
+Separator
+0 hub,user Message of the day
+Chat 0 !motd
+0 hub,user Hub rules
+Chat 0 !rules
+0 hub,user Chat history
+Chat 0 !history %[line:How many lines of history do you want to see?]
+
+# Put a separator before operator commands.
+4 user OpSeparator
+Separator
+
+# Kick and user info commands.
+4 user Kick user
+PM 0 Selected You are being kicked: %[line:Reason for kick]
+Chat 1 is kicking %[userNI]: %[line:Reason for kick]
+Chat 0 !kick %[userNI]
+4 user Get user's IP
+Chat 0 !getip %[userNI]
+4 user,hub Find user with certain IP
+Chat 0 !whoip %[line:Enter IP]
+4 user,hub Find users within IP range
+Chat 0 !whoip %[line:Enter range (can use <start>-<end> or <ip>/<mask> CIDR notation)]
+
+# Log/broadcast commands.
+4 user,hub LogSeparator
+Separator
+4 user,hub Show log
+Chat 0 !log
+4 user,hub Broadcast PM to all users
+Chat 0 !broadcast %[line:Enter message to broadcast to all users]
+
+# Admin commands.
+7 user,hub AdminSeparator
+Separator
+7 user,hub Hub statistics
+Chat 0 !stats
+7 user,hub Reload configuration files
+Chat 0 !reload
+7 user,hub Shutdown hub
+Chat 0 !shutdown
+
+# Finish off with the help command after a separator.
+0 hub,user HelpSeparator
+Separator
+0 hub,user Help
+Chat 0 !help
+
+# Sample configuration for a quote recording bot connected to the hub, with
+# commands displayed in a sub-menu.
+#
+# This assumes you have reserved_sids=QuoteBot in your uhub configuration file,
+# which will reserve the SID AAAB for the QuoteBot user (remember you must also
+# register an account for QuoteBot for this to work). Note that if the bot is
+# offline the hub will drop any message destined for the bot.
+#
+# NB. if you just want to see how this looks, you can uncomment the following
+# lines even if you don't have such a bot - the commands will still be sent out
+# to users, they just won't do anything.
+#
+#0 hub,user QuoteBot\Get latest quote
+#PM 0 AAAB !latest
+#0 hub,user QuoteBot\Get random quote
+#PM 0 AAAB !random
+#0 hub,user QuoteBot\Separator
+#Separator
+#0 hub,user QuoteBot\Add quote
+#PM 0 AAAB !add %[line:Enter quote to add]
+#4 hub,user QuoteBot\Delete quote
+#PM 0 AAAB !delete %[line:Enter number of quote to delete]
diff --git a/doc/uhub.conf b/doc/uhub.conf
index d379b0c..b6430c4 100644
--- a/doc/uhub.conf
+++ b/doc/uhub.conf
@@ -28,6 +28,13 @@ show_banner_sys_info=1
 # Allow only registered users on the hub if set to 1.
 registered_users_only=0
 
+# Reserve SIDs for certain users. These users must have a registered account.
+# CHANGES TO THIS VALUE WILL NOT BE NOTICED BY A CONFIGURATION RELOAD, YOU
+# MUST RESTART THE HUB FOR THEM TO TAKE EFFECT.
+#
+# QuoteBot = AAAB, StatBot = AAAC
+# reserved_sids=QuoteBot StatBot
+
 # A server name and description.
 hub_name=my hub
 hub_description=Powered by uHub
diff --git a/src/core/commands.c b/src/core/commands.c
index fb3256c..4bb1401 100644
--- a/src/core/commands.c
+++ b/src/core/commands.c
@@ -450,7 +450,7 @@ static int command_whoip(struct command_base* cbase, struct hub_user* user, stru
 static int command_broadcast(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd)
 {
 	struct hub_command_arg_data* arg = hub_command_arg_next(cmd, type_string);
-	char* message = arg->data.string;
+	char* message = adc_msg_escape(arg->data.string);
 	size_t message_len = strlen(message);
 	char pm_flag[7] = "PM";
 	char from_sid[5];
@@ -485,6 +485,7 @@ static int command_broadcast(struct command_base* cbase, struct hub_user* user,
 
 	cbuf_append_format(buf, "*** %s: Delivered to " PRINTF_SIZE_T " user%s", cmd->prefix, recipients, (recipients != 1 ? "s" : ""));
 	send_message(cbase, user, buf);
+	hub_free(message);
 	return 0;
 }
 
diff --git a/src/core/config.xml b/src/core/config.xml
index b5e949d..11b2635 100644
--- a/src/core/config.xml
+++ b/src/core/config.xml
@@ -117,6 +117,27 @@
 		<since>0.4.0</since>
    </option>
 
+   <option name="reserved_sids" type="string" default="">
+		<short>Alias reserved SIDs to certain users.</short>
+		<check regexp="((\S+)(\s(\S+))*)?" />
+		<description><![CDATA[
+			<p>
+			When setting up user commands, you may want to be able to use them to private message a certain account (e.g., a bot connected to the hub). Since a session ID (SID) is allocated to a client prior to it sending its nickname, this is not directly possible. Instead, you can reserve fixed SIDs which are aliased to a particular user when they connect. As they are reserved when the hub starts up, these have predictable values.
+			</p>
+			<p>
+			Each nickname in the list must be separated by a space. The SID AAAA is reserved for the hub itself. The first nickname in the list will be aliased to AAAB, the second to AAAC and so on. Fixed SIDs can only be allocated to registered users - if somebody without a password logs in under a reserved nickname, the alias will not be applied (but they can still log in). Also, they are only checked when a private message is sent, so any other messages to/from the aliased SID will be dropped as an unknown user per the ADC protocol.
+			</p>
+			<p>
+			<strong>As these SIDs are reserved when the hub starts up, any change to the values are ignored when the configuration is reloaded. You have to restart the hub for the changes to take effect.</strong>
+			</p>
+		]]></description>
+		<example><![CDATA[
+			# QuoteBot = AAAB, StatBot = AAAC
+			reserved_sids = QuoteBot StatBot
+		]]></example>
+		<since>0.5.0</since>
+   </option>
+
 	<option name="obsolete_clients" type="boolean" default="0">
 		<short>Support obsolete clients using a ADC protocol prior to 1.0</short>
 		<description><![CDATA[
diff --git a/src/core/gen_config.c b/src/core/gen_config.c
index 063db97..eb7db23 100644
--- a/src/core/gen_config.c
+++ b/src/core/gen_config.c
@@ -12,6 +12,7 @@ void config_defaults(struct hub_config* config)
 	config->max_users = 500;
 	config->registered_users_only = 0;
 	config->register_self = 0;
+	config->reserved_sids = hub_strdup("");
 	config->obsolete_clients = 0;
 	config->chat_is_privileged = 0;
 	config->hub_name = hub_strdup("uhub");
@@ -195,6 +196,16 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
+	if (!strcmp(key, "reserved_sids"))
+	{
+		if (!apply_string(key, data, &config->reserved_sids, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+
 	if (!strcmp(key, "obsolete_clients"))
 	{
 		if (!apply_boolean(key, data, &config->obsolete_clients))
@@ -937,6 +948,8 @@ void free_config(struct hub_config* config)
 
 	hub_free(config->server_alt_ports);
 
+	hub_free(config->reserved_sids);
+
 	hub_free(config->hub_name);
 
 	hub_free(config->hub_description);
@@ -1059,6 +1072,9 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	if (!ignore_defaults || config->register_self != 0)
 		fprintf(stdout, "register_self = %s\n", config->register_self ? "yes" : "no");
 
+	if (!ignore_defaults || strcmp(config->reserved_sids, "") != 0)
+		fprintf(stdout, "reserved_sids = \"%s\"\n", config->reserved_sids);
+
 	if (!ignore_defaults || config->obsolete_clients != 0)
 		fprintf(stdout, "obsolete_clients = %s\n", config->obsolete_clients ? "yes" : "no");
 
diff --git a/src/core/gen_config.h b/src/core/gen_config.h
index a6effe1..8f3cac0 100644
--- a/src/core/gen_config.h
+++ b/src/core/gen_config.h
@@ -12,6 +12,7 @@ struct hub_config
 	int   max_users;                       /*<<< Maximum number of users allowed on the hub (default: 500) */
 	int   registered_users_only;           /*<<< Allow registered users only (default: 0) */
 	int   register_self;                   /*<<< Allow users to register themselves on the hub. (default: 0) */
+	char* reserved_sids;                   /*<<< Alias reserved SIDs to certain users. (default: "") */
 	int   obsolete_clients;                /*<<< Support obsolete clients using a ADC protocol prior to 1.0 (default: 0) */
 	int   chat_is_privileged;              /*<<< Allow chat for operators and above only (default: 0) */
 	char* hub_name;                        /*<<< Name of hub (default: "uhub") */
diff --git a/src/core/hub.c b/src/core/hub.c
index 8697f96..d0160a8 100644
--- a/src/core/hub.c
+++ b/src/core/hub.c
@@ -342,7 +342,14 @@ int hub_handle_chat_message(struct hub_info* hub, struct hub_user* u, struct adc
 		{
 			struct hub_user* target = uman_get_user_by_sid(hub, cmd->target);
 			if (target)
+			{
+				/* The SID the PM was sent to is reserved for some user. Hence
+				 * we need to update the target SID in the message so it is
+				 * routed properly. */
+				if(cmd->target != target->id.sid) strncpy(cmd->cache + 10, sid_to_string(target->id.sid), 4);
+
 				status = plugin_handle_private_message(hub, u, target, message_decoded, 0);
+			}
 			else
 				relay = 0;
 		}
diff --git a/src/core/plugincallback.c b/src/core/plugincallback.c
index fb782fb..e4e0667 100644
--- a/src/core/plugincallback.c
+++ b/src/core/plugincallback.c
@@ -51,18 +51,29 @@ static int plugin_command_dispatch(struct command_base* cbase, struct hub_user*
 	return 0;
 }
 
-static struct hub_user* convert_user_type(struct plugin_user* user)
+static struct hub_user* convert_user_type(struct plugin_handle* plugin, struct plugin_user* user)
 {
-	struct hub_user* huser = (struct hub_user*) user;
-	return huser;
+	/* The plugin_user is not guaranteed to point at the same memory as the
+	 * corresponding hub_user - for example, get_user_list() makes a copy of
+	 * the data in case the user quits before the plugin uses the list. Hence
+	 * we need to look it up by SID. */
+	struct hub_info* hub = plugin_get_hub(plugin);
+	struct hub_user* huser = uman_get_user_by_sid(hub, user->sid);
+
+	/* Also need to check the CID matches to handle
+	 * the case where the SID is re-used. */
+	if(huser->id.cid == user->cid) return huser;
+	return NULL;
 }
 
 static int cbfunc_send_message(struct plugin_handle* plugin, struct plugin_user* user, const char* message)
 {
+	struct hub_user* huser = convert_user_type(plugin, user);
+	if(huser == NULL) return 0;
 	char* buffer = adc_msg_escape(message);
 	struct adc_message* command = adc_msg_construct(ADC_CMD_IMSG, strlen(buffer) + 6);
 	adc_msg_add_argument(command, buffer);
-	route_to_user(plugin_get_hub(plugin), convert_user_type(user), command);
+	route_to_user(plugin_get_hub(plugin), huser, command);
 	adc_msg_free(command);
 	hub_free(buffer);
 	return 1;
@@ -70,13 +81,15 @@ static int cbfunc_send_message(struct plugin_handle* plugin, struct plugin_user*
 
 static int cbfunc_send_status(struct plugin_handle* plugin, struct plugin_user* user, int code, const char* message)
 {
+	struct hub_user* huser = convert_user_type(plugin, user);
+	if(huser == NULL) return 0;
 	char code_str[4];
 	char* buffer = adc_msg_escape(message);
 	struct adc_message* command = adc_msg_construct(ADC_CMD_ISTA, strlen(buffer) + 10);
 	snprintf(code_str, sizeof(code_str), "%03d", code);
 	adc_msg_add_argument(command, code_str);
 	adc_msg_add_argument(command, buffer);
-	route_to_user(plugin_get_hub(plugin), convert_user_type(user), command);
+	route_to_user(plugin_get_hub(plugin), huser, command);
 	adc_msg_free(command);
 	hub_free(buffer);
 	return 1;
@@ -84,7 +97,8 @@ static int cbfunc_send_status(struct plugin_handle* plugin, struct plugin_user*
 
 static int cbfunc_user_disconnect(struct plugin_handle* plugin, struct plugin_user* user)
 {
-	hub_disconnect_user(plugin_get_hub(plugin), convert_user_type(user), quit_kicked);
+	struct hub_user* huser = convert_user_type(plugin, user);
+	if(huser != NULL) hub_disconnect_user(plugin_get_hub(plugin), huser, quit_kicked);
 	return 0;
 }
 
@@ -185,6 +199,99 @@ static void cbfunc_set_hub_description(struct plugin_handle* plugin, const char*
 	hub_free(new_str);
 }
 
+/* Get a list of users currently connected to the hub. The list can be filtered
+ * with the credentials parameter:
+ * - auth_cred_none means no filtering i.e., everybody returned.
+ * - Any of the other auth_cred_xxx values means only users of that credential
+ *   level are returned.
+ * - The negative of an auth_cred_xxx value means only users of at least that
+ *   credential level are returned. For example, -auth_cred_operators returns
+ *   any operators or admins.
+ *
+ * NULL is returned on error, and an empty list is returned if no users match
+ * the requested credentials.
+ */
+static struct linked_list* cbfunc_get_user_list(struct plugin_handle* plugin, enum auth_credentials credentials)
+{
+	/* Determine the comparison mode. */
+	int atleast = 0;
+	if((int)credentials < 0)
+	{
+		credentials = -credentials;
+		atleast = 1;
+	}
+
+	/* Check the credential level is valid. */
+	uhub_assert(credentials <= auth_cred_admin);
+
+	/* Get the master user list and prepare our copy. */
+	struct hub_info* hub = plugin_get_hub(plugin);
+	struct linked_list* orig_list = hub->users->list;
+	struct linked_list* new_list = list_create();
+	if(new_list == NULL)
+	{
+		plugin->error_msg = "Unable to allocate memory for user list";
+		return NULL;
+	}
+
+	/* Go through each connected user. */
+	struct hub_user* user = (struct hub_user*)list_get_first(orig_list);
+	while(user != NULL)
+	{
+		/* Check if we should be including them in the output. */
+		int include = 0;
+		if(credentials == 0) include = 1;
+		else
+		{
+			if(atleast)
+			{
+				if(user->credentials >= credentials) include = 1;
+			}
+			else
+			{
+				if(user->credentials == credentials) include = 1;
+			}
+		}
+
+		/* Do we need to include this user? */
+		if(include)
+		{
+			/* Try to allocate space. We are going to make a copy of the user
+			 * data in case the user disconnects before the plugin uses the
+			 * list. This way, any hub functions the plugin tries to call will
+			 * fail, but at least it won't be trying to access free'd memory. */
+			struct plugin_user* puser = (struct plugin_user*)hub_malloc(sizeof(struct plugin_user));
+			if(puser == NULL)
+			{
+				plugin->error_msg = "Unable to allocate memory for list entry in get_user_list.";
+				list_clear(new_list, &hub_free);
+				list_destroy(new_list);
+				return NULL;
+			}
+
+			/* Copy the pertinent information across and add it to the list. */
+			memcpy(puser, user, sizeof(struct plugin_user));
+			list_append(new_list, puser);
+		}
+
+		/* Next user please. */
+		user = (struct hub_user*)list_get_next(orig_list);
+	}
+
+	/* Done. */
+	return new_list;
+}
+
+/* Clean up the memory used by a user list. */
+static void cbfunc_free_user_list(struct plugin_handle* handle, struct linked_list* list)
+{
+	if(list != NULL)
+	{
+		list_clear(list, &hub_free);
+		list_destroy(list);
+	}
+}
+
 void plugin_register_callback_functions(struct plugin_handle* handle)
 {
 	handle->hub.send_message = cbfunc_send_message;
@@ -198,6 +305,13 @@ void plugin_register_callback_functions(struct plugin_handle* handle)
 	handle->hub.set_name = cbfunc_set_hub_name;
 	handle->hub.get_description = cbfunc_get_hub_description;
 	handle->hub.set_description = cbfunc_set_hub_description;
+	handle->hub.ucmd_create = cbfunc_ucmd_create;
+	handle->hub.ucmd_add_chat = cbfunc_ucmd_add_chat;
+	handle->hub.ucmd_add_pm = cbfunc_ucmd_add_pm;
+	handle->hub.ucmd_send = cbfunc_ucmd_send;
+	handle->hub.ucmd_free = cbfunc_ucmd_free;
+	handle->hub.get_user_list = cbfunc_get_user_list;
+	handle->hub.free_user_list = cbfunc_free_user_list;
 }
 
 void plugin_unregister_callback_functions(struct plugin_handle* handle)
diff --git a/src/core/pluginucmd.c b/src/core/pluginucmd.c
new file mode 100644
index 0000000..0b81e93
--- /dev/null
+++ b/src/core/pluginucmd.c
@@ -0,0 +1,415 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2012, Blair Bonnett
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+/* Internal helper function - expand the ucmd->tt member to accomodate the
+ * given number of byes size. Copies and then frees any existing data.  All
+ * unused bytes will be set to zero. Returns 1 on success, 0 if the memory
+ * could not be allocated.
+ *
+ * If size is less than the existing capacity, no change is made.
+ *
+ * NB. one extra byte is always allocated to act as the end-of-string
+ * terminator, i.e., the size can be the length of the string ignoring the
+ * terminator. Since unused bytes are set to zero, there should always be a
+ * terminator.
+ */
+static int ucmd_expand_tt(struct plugin_ucmd* ucmd, size_t size)
+{
+	if(size < ucmd->capacity) return 1;
+
+	/* Try to allocate the space. NB we add one to the space to enforce a null
+	 * byte. */
+	char* newtt = (char*)hub_malloc_zero(size+1);
+	if(newtt == NULL) return 0;
+
+	/* Copy any existing data. */
+	if(ucmd->tt != NULL)
+	{
+		memcpy(newtt, ucmd->tt, ucmd->length);
+		hub_free(ucmd->tt);
+	}
+
+	/* Update the structure. */
+	ucmd->tt = newtt;
+	ucmd->capacity = size;
+	return 1;
+}
+
+/* Calculate the number of characters needed to store the escaped message. */
+static size_t ucmd_msg_escape_length(const char* message)
+{
+	size_t i;
+	size_t extra = 0;
+
+	/* Keep track of substitution blocks. */
+	int substart = 0;  /* Possible start of a block. */
+	int sublevel = 0;  /* Number of nested blocks we are in. */
+
+	for(i = 0; message[i]; i++)
+	{
+		switch(message[i])
+		{
+			/* Character to escape. */
+			case ' ':
+			case '\n':
+			case '\\':
+				if(!sublevel) extra++;
+				substart = 0;
+				break;
+
+			/* Heading into a substitution block. */
+			case '%':
+				substart = 1;
+				break;
+			case '[':
+				if(substart) sublevel++;
+				substart = 0;
+				break;
+
+			/* Coming out of a substitution block. */
+			case ']':
+				substart = 0;
+				if(sublevel) sublevel --;
+				break;
+
+			default:
+				break;
+		}
+	}
+
+	/* Done. */
+	return i + extra;
+}
+
+/* Escape a message that is being put into a user command. We cannot use
+ * adc_msg_escape for this as keyword substitutions should not be escaped while
+ * general text should be. */
+static char* ucmd_msg_escape(const char* message)
+{
+	/* Allocate the memory we need. */
+	size_t esclen = ucmd_msg_escape_length(message);
+	char *escaped = hub_malloc(esclen + 1);
+	if(escaped == NULL) return NULL;
+
+	/* Keep track of substitution blocks. */
+	int substart = 0;  /* Possible start of a block. */
+	int sublevel = 0;  /* Number of nested blocks we are in. */
+
+	size_t i;
+	size_t n = 0;
+	for(i = 0; message[i]; i++)
+	{
+		switch(message[i])
+		{
+			/* Characters to escape provided we are *outside*
+			 * any substitution blocks. */
+			case ' ':
+				if(sublevel)
+				{
+					escaped[n++] = ' ';
+				}
+				else
+				{
+					escaped[n++] = '\\';
+					escaped[n++] = 's';
+				}
+				substart = 0;
+				break;
+			case '\n':
+				if(sublevel)
+				{
+					escaped[n++] = '\n';
+				}
+				else
+				{
+					escaped[n++] = '\\';
+					escaped[n++] = 'n';
+					substart = 0;
+					break;
+				}
+			case '\\':
+				escaped[n++] = '\\';
+				if(!sublevel) escaped[n++] = '\\';
+				substart = 0;
+				break;
+
+			/* Heading into a substitution block. */
+			case '%':
+				escaped[n++] = '%';
+				substart = 1;
+				break;
+			case '[':
+				escaped[n++] = '[';
+				if(substart) sublevel++;
+				substart = 0;
+				break;
+
+			/* Coming out of a substitution block. */
+			case ']':
+				escaped[n++] = ']';
+				if(sublevel) sublevel--;
+				substart = 0;
+				break;
+
+			/* Normal character. */
+			default:
+				escaped[n++] = message[i];
+				substart = 0;
+				break;
+		}
+	}
+
+	/* Done. */
+	escaped[n] = 0;
+	return escaped;
+}
+
+struct plugin_ucmd* cbfunc_ucmd_create(struct plugin_handle* plugin, const char* name, size_t length){
+	/* Need a name. */
+	if(name == NULL)
+	{
+		plugin->error_msg = "Each user command needs a name.";
+		return NULL;
+	}
+
+	/* Allocate space for the command structure. */
+	struct plugin_ucmd* cmd = (struct plugin_ucmd*)hub_malloc(sizeof(struct plugin_ucmd));
+	if(cmd == NULL)
+	{
+		plugin->error_msg = "Not enough memory to create user command.";
+		return NULL;
+	}
+
+	/* Store the name and initialise the flags. */
+	cmd->categories = 0;
+	cmd->remove = 0;
+	cmd->separator = 0;
+	cmd->constrained = 0;
+	cmd->name = adc_msg_escape(name);
+	cmd->namelen = strlen(cmd->name);
+	cmd->tt = NULL;
+	cmd->length = 0;
+	cmd->capacity = 0;
+
+	/* Allocate space for the command data. 18 bytes is the overhead for a chat
+	 * message so we need to add space for this. */
+	length = ((length < 0) ? 0 : length) + 18;
+	int result = ucmd_expand_tt(cmd, length);
+	if(result == 0)
+	{
+		plugin->error_msg = "Not enough memory to store user command data.";
+		cbfunc_ucmd_free(plugin, cmd);
+		return NULL;
+	}
+
+	/* Done. */
+	return cmd;
+}
+
+int cbfunc_ucmd_add_chat(struct plugin_handle* plugin, struct plugin_ucmd* ucmd, const char* message, int me)
+{
+	/* Double-escape the message - once for when the client sends it back, and
+	 * then again to insert it into the user command message we send to them.
+	 * Note the two different escape functions used for the different escapes -
+	 * the UCMD escape is needed to handle substitution blocks correctly. */
+	char* temp = ucmd_msg_escape(message);
+	char* escmsg = adc_msg_escape(temp);
+	hub_free(temp);
+	size_t msglen = strlen(escmsg);
+
+	/* Format of a chat message: "BMSG\s%[mySID]\s<double-escaped message>\n".
+	 * Format of a 'me' chat message: "BMSG\s%[mySID]\s<double-escaped message>\sME1\n". */
+	size_t required = 18 + msglen + (me ? 5 : 0);
+	if(required > (ucmd->capacity - ucmd->length))
+	{
+		if(ucmd_expand_tt(ucmd, ucmd->capacity + required) == 0)
+		{
+			plugin->error_msg = "Could not expand memory to store chat message.";
+			hub_free(escmsg);
+			return 0;
+		}
+	}
+
+	/* Add in the chat command and placeholder for the client SID. */
+	strncpy(ucmd->tt + ucmd->length, "BMSG\\s%[mySID]\\s", 16);
+	ucmd->length += 16;
+
+	/* Copy the message. */
+	strncpy(ucmd->tt + ucmd->length, escmsg, msglen);
+	ucmd->length += msglen;
+	hub_free(escmsg);
+
+	/* If it is a 'me' message, add the flag. */
+	if(me)
+	{
+		strncpy(ucmd->tt + ucmd->length, "\\sME1", 5);
+		ucmd->length += 5;
+	}
+
+	/* Add the (escaped) line break. */
+	ucmd->tt[ucmd->length++] = '\\';
+	ucmd->tt[ucmd->length++] = 'n';
+
+	/* Done. */
+	return 1;
+}
+
+int cbfunc_ucmd_add_pm(struct plugin_handle* plugin, struct plugin_ucmd* ucmd, const char* to, const char* message, int echo)
+{
+	/* Double-escape the message - once for when the client sends it back, and
+	 * then again to insert it into the user command message we send to them.
+	 * Note the two different escape functions used for the different escapes -
+	 * the UCMD escape is needed to handle substitution blocks correctly. */
+	char* temp = ucmd_msg_escape(message);
+	char* escmsg = adc_msg_escape(temp);
+	hub_free(temp);
+	size_t msglen = strlen(escmsg);
+
+	/* If no target SID is given, use the keyword expansion %[userSID] for the
+	 * client to fill in with the currently selected user. */
+	size_t tolen = (to == NULL) ? 10 : 4;
+
+	/* Format of an echoed PM: "EMSG\s%[mySID]\s<target SID>\s<double-escaped message>\sPM%[mySID]\n".
+	 * Format of a non-echoed PM: "DMSG\s%[mySID]\s<target SID>\s<double-escaped message>\sPM%[mySID]\n". */
+	size_t required = 32 + tolen + msglen;
+	if(required > (ucmd->capacity - ucmd->length))
+	{
+		if(ucmd_expand_tt(ucmd, ucmd->capacity + required) == 0)
+		{
+			plugin->error_msg = "Could not expand memory to store private message.";
+			hub_free(escmsg);
+			return 0;
+		}
+	}
+
+	/* Start with the appropriate ADC command plus the client SID placeholder. */
+	if(echo) strncpy(ucmd->tt + ucmd->length, "EMSG\\s%[mySID]\\s", 16);
+	else strncpy(ucmd->tt + ucmd->length, "DMSG\\s%[mySID]\\s", 16);
+	ucmd->length += 16;
+
+	/* Copy the target ID. */
+	if(to != NULL) strncpy(ucmd->tt + ucmd->length, to, tolen);
+	else strncpy(ucmd->tt + ucmd->length, "%[userSID]", tolen);
+	ucmd->length += tolen;
+
+	/* Space between target and message. */
+	ucmd->tt[ucmd->length++] = '\\';
+	ucmd->tt[ucmd->length++] = 's';
+
+	/* Message. */
+	strncpy(ucmd->tt + ucmd->length, escmsg, msglen);
+	ucmd->length += msglen;
+	hub_free(escmsg);
+
+	/* Add the PM flag and final line break. */
+	strncpy(ucmd->tt + ucmd->length, "\\sPM%[mySID]\\n", 14);
+	ucmd->length += 14;
+
+	/* Done. */
+	return 1;
+}
+
+int cbfunc_ucmd_send(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_ucmd* ucmd)
+{
+	/* Check the user is still connected. */
+	struct hub_info* hub = plugin_get_hub(plugin);
+	struct hub_user* huser = uman_get_user_by_sid(hub, user->sid);
+	if(huser == NULL)
+	{
+		plugin->error_msg = "User is not connected to the hub.";
+		return 0;
+	}
+
+	/* Make sure we have a command. */
+	if(!ucmd->length && !(ucmd->separator || ucmd->remove))
+	{
+		plugin->error_msg = "Cannot send without adding a message.";
+		return 0;
+	}
+
+	/* Make sure the category is valid. */
+	if(!ucmd->remove)
+	{
+		if(ucmd->categories < 1 || ucmd->categories > 15)
+		{
+			plugin->error_msg = "Need a valid category to send.";
+			return 0;
+		}
+	}
+
+	/* Calculate the size needed for the message. */
+	size_t length = ucmd->namelen;
+	if(ucmd->remove || ucmd->separator) length += 4;
+	else
+	{
+		length += 10 + ucmd->length; /* "_TT<arg>\n CTnn" = 10 extra chars. */
+		if(ucmd->constrained) length += 4;
+	}
+
+	/* Create the message structure. */
+	struct adc_message* message = adc_msg_construct(ADC_CMD_ICMD, length);
+	if(message == NULL)
+	{
+		plugin->error_msg = "Cannot allocate space for ADC message.";
+		return 0;
+	}
+
+	/* Always have the name. */
+	adc_msg_add_argument(message, ucmd->name);
+
+	/* Remove / separator. */
+	if(ucmd->remove) adc_msg_add_argument(message, "RM1");
+	if(ucmd->separator)
+	{
+		adc_msg_add_argument(message, "SP1");
+		adc_msg_add_named_argument_int(message, "CT", ucmd->categories);
+	}
+
+	/* Add in the message. */
+	else
+	{
+		adc_msg_add_named_argument(message, "TT", ucmd->tt);
+		if(ucmd->constrained) adc_msg_add_argument(message, "CO1");
+		adc_msg_add_named_argument_int(message, "CT", ucmd->categories);
+	}
+
+	/* Send it. */
+	route_to_user(hub, huser, message);
+
+	/* Success. */
+	adc_msg_free(message);
+	return 1;
+}
+
+void cbfunc_ucmd_free(struct plugin_handle* plugin, struct plugin_ucmd* ucmd){
+	if(ucmd->name != NULL)
+	{
+		hub_free(ucmd->name);
+		ucmd->name = NULL;
+	}
+	if(ucmd->tt != NULL)
+	{
+		hub_free(ucmd->tt);
+		ucmd->tt = NULL;
+	}
+	hub_free(ucmd);
+}
diff --git a/src/core/pluginucmd.h b/src/core/pluginucmd.h
new file mode 100644
index 0000000..d1e4baf
--- /dev/null
+++ b/src/core/pluginucmd.h
@@ -0,0 +1,57 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2012, Blair Bonnett
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_UCMD_H
+#define HAVE_UHUB_PLUGIN_UCMD_H
+
+/* Create a new user command object.
+ * Name: name of the entry in the clients user command menu - must be unique
+ *       within a hub.
+ * Length: approximate length of message to be sent. Other functions can
+ *         increase memory allocation as needed but having a sufficient size
+ *         now removes the time taken for this resizing. Allow a factor of ~1/3
+ *         for the neccesary escaping.
+ */
+extern struct plugin_ucmd* cbfunc_ucmd_create(struct plugin_handle* plugin, const char* name, size_t length);
+
+/* Add a message to be sent in the main chat window when the user command is
+ * clicked.
+ * Me: If true, makes the message displayed in the same style as a '/me'
+ *     message in IRC (and most hub clients).
+ */
+extern int cbfunc_ucmd_add_chat(struct plugin_handle* plugin, struct plugin_ucmd* ucmd, const char* message, int me);
+
+/* Add a private message to be sent when the user command is clicked.
+ * To: The SID of the user to send the message to. Leave it blank to send to
+ *     the user that was right-clicked in the user list (i.e., a context-based
+ *     message - only effective if the user command is in the user category).
+ * Echo: If true, the message is also echoed to the sending user as in a normal
+ *       PM. If false, it is only sent to the target user and the sending user
+ *       will only see any response.
+ */
+extern int cbfunc_ucmd_add_pm(struct plugin_handle* plugin, struct plugin_ucmd* ucmd, const char* to, const char* message, int echo);
+
+/* Send the user command to a user. */
+extern int cbfunc_ucmd_send(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_ucmd* ucmd);
+
+/* Free the space used by a user command object. */
+extern void cbfunc_ucmd_free(struct plugin_handle* plugin, struct plugin_ucmd* command);
+
+#endif /* HAVE_UHUB_PLUGIN_UCMD_H */
diff --git a/src/core/user.h b/src/core/user.h
index 7b7d0b8..283be70 100644
--- a/src/core/user.h
+++ b/src/core/user.h
@@ -39,7 +39,7 @@ enum user_flags
 	feature_base    = 0x00000001, /** BASE: Basic configuration (required by all clients) */
 	feature_auto    = 0x00000002, /** AUT0: Automatic nat detection traversal */
 	feature_bbs     = 0x00000004, /** BBS0: Bulletin board system (not supported) */
-	feature_ucmd    = 0x00000008, /** UCMD: User commands (not supported by this software) */
+	feature_ucmd    = 0x00000008, /** UCMD: User commands */
 	feature_zlif    = 0x00000010, /** ZLIF: gzip stream compression (not supported) */
 	feature_tiger   = 0x00000020, /** TIGR: Client supports the tiger hash algorithm */
 	feature_bloom   = 0x00000040, /** BLO0: Bloom filter (not supported) */
diff --git a/src/core/usermanager.c b/src/core/usermanager.c
index 452eff4..bc08a04 100644
--- a/src/core/usermanager.c
+++ b/src/core/usermanager.c
@@ -73,6 +73,61 @@ static void timer_statistics(struct timeout_evt* t)
 	timeout_queue_reschedule(net_backend_get_timeout_queue(), hub->users->timeout, TIMEOUT_STATS);
 }
 
+int add_reserved_sid(char* nick, int splitcount, void* data)
+{
+	struct hub_user_manager* users = (struct hub_user_manager*)data;
+
+	/* Safety check: make sure the nickname can fit. */
+	size_t nicklen = strlen(nick);
+	if(nicklen > MAX_NICK_LEN)
+	{
+		LOG_ERROR("Nickname %s for reserved SID is too long (length %d, max %d)", nick, nicklen, MAX_NICK_LEN);
+		return -1;
+	}
+
+	/* Try to create a structure for the new reserved SID. */
+	struct reserved_sid* newresv = (struct reserved_sid*)hub_malloc(sizeof(struct reserved_sid));
+	if(newresv == NULL)
+	{
+		LOG_ERROR("Could not allocate memory for reserved SID for %s", nick);
+		return -1;
+	}
+
+	/* Try to create a dummy user for the reserved SID. */
+	newresv->dummy_user = (struct hub_user*)hub_malloc(sizeof(struct hub_user));
+	if(newresv->dummy_user == NULL)
+	{
+		LOG_ERROR("Could not allocate memory for reserved SID for %s", nick);
+		hub_free(newresv);
+		return -1;
+	}
+	strncpy(newresv->dummy_user->id.nick, nick, nicklen+1);
+
+	/* No users logged in at this point. */
+	newresv->real_user = NULL;
+
+	/* Allocate the SID. */
+	newresv->pool = users->sids;
+	newresv->sid = sid_alloc(users->sids, newresv->dummy_user);
+
+	/* Add to the list and keep track of how many we've allocated. */
+	list_append(users->reserved, newresv);
+	users->reserved_end = newresv->sid;
+
+	/* Done. */
+	LOG_INFO("Reserved SID %s for %s", sid_to_string(newresv->sid), newresv->dummy_user->id.nick);
+	return 1;
+}
+
+void remove_reserved_sid(void *node)
+{
+	struct reserved_sid* resv = (struct reserved_sid*)node;
+	LOG_INFO("Removing reserved SID %s for %s", sid_to_string(resv->sid), resv->dummy_user->id.nick);
+	sid_free(resv->pool, resv->sid);
+	hub_free(resv->dummy_user);
+	hub_free(resv);
+}
+
 int uman_init(struct hub_info* hub)
 {
 	struct hub_user_manager* users = NULL;
@@ -100,6 +155,11 @@ int uman_init(struct hub_info* hub)
 		timeout_queue_insert(net_backend_get_timeout_queue(), users->timeout, TIMEOUT_STATS);
 	}
 
+	/* Process any reserved SIDs. */
+	users->reserved = list_create();
+	users->reserved_end = 0;
+	string_split(hub->config->reserved_sids, " ", (void*)users, &add_reserved_sid);
+
 	hub->users = users;
 	return 0;
 }
@@ -116,6 +176,12 @@ int uman_shutdown(struct hub_info* hub)
 		hub_free(hub->users->timeout);
 	}
 
+	if (hub->users->reserved)
+	{
+		list_clear(hub->users->reserved, &remove_reserved_sid);
+		list_destroy(hub->users->reserved);
+	}
+
 	if (hub->users->list)
 	{
 		list_clear(hub->users->list, &clear_user_list_callback);
@@ -138,6 +204,23 @@ int uman_add(struct hub_info* hub, struct hub_user* user)
 	if (user->hub)
 		return -1;
 
+	/* Check if a SID has been reserved for this user. NB. user must be
+	 * registered for reserved SIDs to be used. */
+	if(hub->users->reserved_end && user->credentials >= auth_cred_user)
+	{
+		struct reserved_sid* resv = (struct reserved_sid*)list_get_first(hub->users->reserved);
+		while(resv)
+		{
+			if(strcmp(resv->dummy_user->id.nick, user->id.nick) == 0)
+			{
+				resv->real_user = user;
+				LOG_INFO("Reserved user %s logged in.", user->id.nick);
+				break;
+			}
+			resv = (struct reserved_sid*)list_get_next(hub->users->reserved);
+		}
+	}
+
 	list_append(hub->users->list, user);
 	hub->users->count++;
 	hub->users->count_peak = MAX(hub->users->count, hub->users->count_peak);
@@ -154,6 +237,22 @@ int uman_remove(struct hub_info* hub, struct hub_user* user)
 	if (!hub || !user)
 		return -1;
 
+	/* Check if a SID has been reserved for this user. */
+	if(hub->users->reserved_end)
+	{
+		struct reserved_sid* resv = (struct reserved_sid*)list_get_first(hub->users->reserved);
+		while(resv)
+		{
+			if(resv->real_user == user)
+			{
+				resv->real_user = NULL;
+				LOG_INFO("Reserved user %s has left the building.", user->id.nick);
+				break;
+			}
+			resv = (struct reserved_sid*)list_get_next(hub->users->reserved);
+		}
+	}
+
 	list_remove(hub->users->list, user);
 
 	if (hub->users->count > 0)
@@ -176,6 +275,17 @@ int uman_remove(struct hub_info* hub, struct hub_user* user)
 
 struct hub_user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid)
 {
+	/* This is a reserved SID. */
+	if(sid && sid <= hub->users->reserved_end)
+	{
+		struct reserved_sid* resv = (struct reserved_sid*)list_get_index(hub->users->reserved, sid-1);
+
+		/* See if the real user is currently logged on and return accordingly. */
+		if(resv->real_user != NULL) return resv->real_user;
+		return 0;
+	}
+
+	/* Use the SID lookup code. */
 	return sid_lookup(hub->users->sids, sid);
 }
 
diff --git a/src/core/usermanager.h b/src/core/usermanager.h
index 7cc5190..65e252e 100644
--- a/src/core/usermanager.h
+++ b/src/core/usermanager.h
@@ -20,6 +20,14 @@
 #ifndef HAVE_UHUB_USER_MANAGER_H
 #define HAVE_UHUB_USER_MANAGER_H
 
+struct reserved_sid
+{
+	sid_t sid;                   /**<< "Reserved SID" */
+	struct sid_pool* pool;       /**<< "Pool the SID was reserved from" */
+	struct hub_user* dummy_user; /**<< "Dummy user account for the reserved SID" */
+	struct hub_user* real_user;  /**<< "Real user account the SID links to, or NULL if not logged in" */
+};
+
 struct hub_user_manager
 {
 	size_t count;                   /**<< "Number of all fully connected and logged in users" */
@@ -29,6 +37,8 @@ struct hub_user_manager
 	uint64_t shared_files;          /**<< "The total number of shared files among fully connected users." */
 	struct linked_list* list;       /**<< "Contains all logged in users" */
 	struct timeout_evt* timeout;    /**<< "Timeout handler for statistics" */
+	struct linked_list* reserved;   /**<< "Contains reserved SID information" */
+	sid_t reserved_end;             /**<< "Value of last reserved SID" */
 };
 
 /**
diff --git a/src/plugin_api/handle.h b/src/plugin_api/handle.h
index b9ab3ea..4644ac2 100644
--- a/src/plugin_api/handle.h
+++ b/src/plugin_api/handle.h
@@ -123,6 +123,15 @@ typedef void  (*hfunc_set_hub_name)(struct plugin_handle*, const char*);
 typedef char* (*hfunc_get_hub_description)(struct plugin_handle*);
 typedef void  (*hfunc_set_hub_description)(struct plugin_handle*, const char*);
 
+typedef struct plugin_ucmd* (*hfunc_ucmd_create)(struct plugin_handle*, const char*, size_t);
+typedef int                 (*hfunc_ucmd_add_chat)(struct plugin_handle*, struct plugin_ucmd*, const char*, int);
+typedef int                 (*hfunc_ucmd_add_pm)(struct plugin_handle*, struct plugin_ucmd*, const char*, const char*, int);
+typedef int                 (*hfunc_ucmd_send)(struct plugin_handle*, struct plugin_user*, struct plugin_ucmd*);
+typedef void                (*hfunc_ucmd_free)(struct plugin_handle*, struct plugin_ucmd*);
+
+typedef struct linked_list* (*hfunc_get_user_list)(struct plugin_handle*, enum auth_credentials);
+typedef void                (*hfunc_free_user_list)(struct plugin_handle*, struct linked_list*);
+
 /**
  * These are functions created and initialized by the hub and which can be used
  * by plugins to access functionality internal to the hub.
@@ -140,6 +149,13 @@ struct plugin_hub_funcs
 	hfunc_set_hub_name set_name;
 	hfunc_get_hub_description get_description;
 	hfunc_set_hub_description set_description;
+	hfunc_ucmd_create ucmd_create;
+	hfunc_ucmd_add_chat ucmd_add_chat;
+	hfunc_ucmd_add_pm ucmd_add_pm;
+	hfunc_ucmd_send ucmd_send;
+	hfunc_ucmd_free ucmd_free;
+	hfunc_get_user_list get_user_list;
+	hfunc_free_user_list free_user_list;
 };
 
 struct plugin_handle
diff --git a/src/plugin_api/types.h b/src/plugin_api/types.h
index 4fce255..8cac2f7 100644
--- a/src/plugin_api/types.h
+++ b/src/plugin_api/types.h
@@ -20,7 +20,7 @@
 #ifndef HAVE_UHUB_PLUGIN_TYPES_H
 #define HAVE_UHUB_PLUGIN_TYPES_H
 
-#define PLUGIN_API_VERSION 1
+#define PLUGIN_API_VERSION 2
 
 #ifndef MAX_NICK_LEN
 #define MAX_NICK_LEN 64
@@ -103,5 +103,57 @@ enum plugin_command_arg_type
 	plugin_cmd_arg_type_credentials,
 };
 
+/* Specifies which categories a command appears in. To make a command appear in
+ * multiple categories, simply OR the appropriate values together. */
+enum plugin_ucmd_categories
+{
+	/* Appears in the main hub chat window. */
+	ucmd_category_hub = 1,
+
+	/* Appears in the hub user list. */
+	ucmd_category_user = 2,
+
+	/* Appears in the search results. */
+	ucmd_category_search = 4,
+
+	/* Appears in the file list. */
+	ucmd_category_file = 8,
+
+	/* Special case: appear everywhere. */
+	ucmd_category_all = 15,
+};
+
+/* Holds information about a user command. Note that a unique name is required
+ * for every command, even if it is only a separator.
+ *
+ * You should not create one of these yourself but instead use the
+ * plugin_handle->hub.ucmd_create() function.
+ *
+ * Similarly, you should only manually modify the first four entries below, and
+ * use the plugin_handle->hub.ucmd_xxxx() functions to make any other changes.
+ * */
+struct plugin_ucmd
+{
+	/* Which categories the command appears in. */
+	enum plugin_ucmd_categories categories;
+
+	/* If true, removes an existing command rather than adding a new one. */
+	int remove;
+
+	/* If true, adds a separator to the user command menu rather than an actual command. */
+	int separator;
+
+	/* Sometimes a command can be sent on multiple users (e.g., in search
+	 * results). If this field is true, the command is limited to run once per
+	 * CID. */
+	int constrained;
+
+	/* Plugins must not modify the following fields. */
+	char *name;
+	size_t namelen;
+	char *tt;
+	size_t length;
+	size_t capacity;
+};
 
 #endif /* HAVE_UHUB_PLUGIN_TYPES_H */
diff --git a/src/plugins/mod_ucmd.c b/src/plugins/mod_ucmd.c
new file mode 100644
index 0000000..385d506
--- /dev/null
+++ b/src/plugins/mod_ucmd.c
@@ -0,0 +1,501 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ *
+ * User command plugin
+ * Copyright (C) 2012, Blair Bonnett
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "plugin_api/types.h"
+#include "util/list.h"
+#include "util/memory.h"
+#include "util/misc.h"
+#include "util/config_token.h"
+
+/* Plugin data. Stores a linked list of the commands for each credential level. */
+struct ucmd_data{
+	struct linked_list* commands[auth_cred_admin]; /* Don't need to store commands for auth_cred_none. */
+};
+
+/* State used to keep track of where we are in parsing the user command file. */
+struct parse_state
+{
+	struct plugin_handle* plugin;
+	struct ucmd_data* data;
+	struct plugin_ucmd* ucmd;          /* Command we are currently parsing. */
+	enum auth_credentials credentials; /* Credentials the command requires. */
+	int actions;                       /* How many actions have been added to the command so far. */
+};
+
+/* Callback run when a user logs in. */
+void on_user_login(struct plugin_handle* plugin, struct plugin_user* user){
+	struct plugin_ucmd* ucmd;
+
+	/* 0 = auth_cred_none. Should never be called with a non-logged-in user but
+	 * do a sanity check to be sure. */
+	if(!user->credentials) return;
+
+	/* Get the list of commands for this credential level. NB the offset of -1
+	 * caused by not storing a list for auth_cred_none. */
+	struct ucmd_data *data = (struct ucmd_data *)plugin->ptr;
+	struct linked_list* clist = data->commands[user->credentials - 1];
+
+	/* Loop through and send all commands to the new user. */
+	ucmd = list_get_first(clist);
+	while(ucmd)
+	{
+		plugin->hub.ucmd_send(plugin, user, ucmd);
+		ucmd = list_get_next(clist);
+	}
+}
+
+/* Adds a parsed command to the lists for the credential levels that can access it. */
+void add_command(struct ucmd_data* data, struct plugin_ucmd* ucmd, enum auth_credentials min_credential)
+{
+	/* Don't store auth_cred_none but we can accept it here to mean everybody,
+	 * so fake it as the next level up. */
+	if(min_credential == auth_cred_none) min_credential = auth_cred_bot;
+
+	/* Add it to the lists of all matching credentials. */
+	int i;
+	for(i = min_credential - 1; i < auth_cred_admin; i++){
+		list_append(data->commands[i], (void*)ucmd);
+	}
+}
+
+/* Frees up all the memory used in the plugin data structure, including the
+ * structure itself. */
+void free_data(struct plugin_handle* plugin, struct ucmd_data* data)
+{
+	if(data != NULL){
+		/* Clear up the linked lists. */
+		int i, j;
+		for(i = 0; i < auth_cred_admin; i++)
+		{
+			struct plugin_ucmd* ucmd = list_get_first(data->commands[i]);
+			while(ucmd != NULL)
+			{
+				/* Remove the commands in this list from the higher lists (they are
+				 * bound to exist in them due to the way the credentials are
+				 * ordered). This is neccessary to avoid a double-free when
+				 * clearing the higher lists. */
+				for(j = i + 1; j < auth_cred_admin; j++) list_remove(data->commands[j], ucmd);
+
+				/* Free the command memory. */
+				plugin->hub.ucmd_free(plugin, ucmd);
+
+				/* Remove it from the list and move on to the next one. */
+				list_remove(data->commands[i], ucmd);
+				ucmd = list_get_next(data->commands[i]);
+			}
+
+			/* Done with this list. */
+			list_destroy(data->commands[i]);
+		}
+
+		/* Done with the data structure. */
+		hub_free(data);
+	}
+}
+
+/* Parses the first line of a command entry, and creates a new user command
+ * object (if possible) in the state structure. Any existing object is
+ * overwritten - it is up to the calling function to handle this first. If an
+ * error occurs, sets an appropriate message and returns -1. Returns 1 on
+ * success. */
+int parse_first_line(struct parse_state* state, char* line)
+{
+	/* Check the credential level. */
+	if(line[0] < '0' || line[0] > '7')
+	{
+		state->plugin->error_msg = "Command must start with a valid credential level.";
+		return -1;
+	}
+	state->credentials = line[0] - '0';
+
+	/* Check for proper formatting. */
+	if(line[1] != ' ')
+	{
+		state->plugin->error_msg = "No context (or misformed context) given.";
+		return -1;
+	}
+
+	/* Parse the context string. */
+	char *start = line + 2;
+	char *end = start;
+	enum plugin_ucmd_categories category = 0;
+	while(1)
+	{
+		/* Move to (a) end of string, (b) next space, or (c) next comma. */
+		while(*end && *end != ' ' && *end != ',') end++;
+
+		/* Check what category this token corresponds to and OR it into the
+		 * overall category. */
+		if(strncasecmp(start, "all", end-start) == 0) category = ucmd_category_all;
+		else if(strncasecmp(start, "hub", end-start) == 0) category |= ucmd_category_hub;
+		else if(strncasecmp(start, "user", end-start) == 0) category |= ucmd_category_user;
+		else if(strncasecmp(start, "search", end-start) == 0) category |= ucmd_category_search;
+		else if(strncasecmp(start, "file", end-start) == 0) category |= ucmd_category_file;
+		else
+		{
+			state->plugin->error_msg = "Invalid context for command.";
+			return -1;
+		}
+
+		/* End of the string ==> no name was given on this line. */
+		if(!*end)
+		{
+			state->plugin->error_msg = "No name for command.";
+			return -1;
+		}
+
+		/* Token ended with a space ==> end of list, next up is the command name. */
+		if(*end == ' '){
+			start = ++end;
+			break;
+		}
+
+		/* Must have been a comma, go through and process the next category given. */
+		start = ++end;
+	}
+
+	/* What is left is the name, so we can create the command. */
+	state->ucmd = state->plugin->hub.ucmd_create(state->plugin, start, 50);
+	state->ucmd->categories = category;
+
+	/* Success. */
+	return 1;
+}
+
+/* Parses a chat message action and updates the current user command object.
+ * Sets an appropriate error message and returns -1 if an error occurs. Returns
+ * 1 on success. */
+int parse_chat(struct parse_state* state, char* args)
+{
+	/* Check for 'me' parameter. */
+	if(args[0] < '0' || args[0] > '1' || args[1] != ' ')
+	{
+		state->plugin->error_msg = "'Me' parameter in chat action must be 0 or 1";
+		return -1;
+	}
+	int me = args[0] - '0';
+
+	/* Check for a message. */
+	char* message = args + 2;
+	if(strlen(message) == 0)
+	{
+		state->plugin->error_msg = "Chat action requires a message to send";
+		return -1;
+	}
+
+	/* Add the message to the command. */
+	int retval = state->plugin->hub.ucmd_add_chat(state->plugin, state->ucmd, message, me);
+	if(retval)
+	{
+		state->actions++;
+		return 1;
+	}
+	return -1;
+}
+
+/* Parses a private message action and adds it to the current user command.
+ * Sets an appropriate message and returns -1 if an error occurs. Returns 1 on
+ * success. */
+int parse_pm(struct parse_state* state, char* args)
+{
+	/* Check for 'echo' parameter. */
+	if(args[0] < '0' || args[0] > '1' || args[1] != ' ')
+	{
+		state->plugin->error_msg = "'Echo' parameter in PM action must be 0 or 1";
+		return -1;
+	}
+	int echo = args[0] - '0';
+
+	/* Decide upon the target. */
+	args += 2;
+	char* target;
+	if(strncasecmp(args, "selected ", 9) == 0)
+	{
+		target = NULL;
+		args += 9;
+	}
+	else
+	{
+		/* Check it is a valid SID. */
+		if(!is_valid_base32_char(args[0]) || !is_valid_base32_char(args[1]) ||
+		   !is_valid_base32_char(args[2]) || !is_valid_base32_char(args[3]) || args[4] != ' ')
+		{
+			state->plugin->error_msg = "Invalid target in PM action";
+			return -1;
+		}
+		args[4] = 0;
+		target = hub_strdup(args);
+		args += 5;
+	}
+
+	/* Add the message. */
+	int retval = state->plugin->hub.ucmd_add_pm(state->plugin, state->ucmd, target, args, echo);
+	if(target != NULL) hub_free(target);
+
+	/* Done. */
+	if(retval)
+	{
+		state->actions++;
+		return 1;
+	}
+	return -1;
+}
+
+/* Parses a line - designed as a callback for the file_read_lines() function.
+ * Does not handle blank lines as they are not passed to callbacks. Sets
+ * appropriate error message and returns -1 on error. Returns 1 on success. The
+ * data parameter should be a pointer to a parse_state structure. */
+int parse_line(char *line, int line_number, void* data)
+{
+	struct parse_state* state = (struct parse_state*)data;
+
+	/* Strip off any whitespace and check we still have something to process. */
+	line = strip_white_space(line);
+	if(strlen(line) == 0) return 1;
+
+	/* Ignore comment lines. */
+	if(line[0] == '#') return 1;
+
+	/* New command. */
+	if(line[0] >= '0' && line[0] <= '9')
+	{
+		/* Existing command we need to finish and add. */
+		if(state->ucmd != NULL)
+		{
+			/* Need at least one action. */
+			if(!state->actions)
+			{
+				state->plugin->error_msg = "A command needs at least one action to perform.";
+				return -1;
+			}
+
+			/* Add the command. */
+			add_command(state->data, state->ucmd, state->credentials);
+			state->ucmd = NULL;
+		}
+
+		/* Reset the flags. */
+		state->actions = 0;
+		state->credentials = auth_cred_none;
+
+		/* Start the new command. */
+		return parse_first_line(state, line);
+	}
+
+	/* New chat message action. */
+	else if(strncasecmp(line, "Chat ", 5) == 0)
+	{
+		if(state->ucmd == NULL)
+		{
+			state->plugin->error_msg = "Command must be defined before an action.";
+			return -1;
+		}
+		if(!state->ucmd->separator) return parse_chat(state, line+5);
+		else return 1;
+	}
+
+	/* New private message action. */
+	else if(strncasecmp(line, "PM ", 3) == 0)
+	{
+		if(state->ucmd == NULL)
+		{
+			state->plugin->error_msg = "Command must be defined before an action.";
+			return -1;
+		}
+		if(!state->ucmd->separator) return parse_pm(state, line+3);
+		else return 1;
+	}
+
+	/* Command is actually a separator. */
+	else if(strncasecmp(line, "Separator", 9) == 0)
+	{
+		if(state->ucmd == NULL)
+		{
+			state->plugin->error_msg = "Command must be defined before an action.";
+			return -1;
+		}
+		state->ucmd->separator = 1;
+		state->actions++;
+		return 1;
+	}
+
+	/* Unknown line. */
+	else
+	{
+		state->plugin->error_msg = "Unknown line in user command file.";
+		return -1;
+	}
+}
+
+/* Parses a user command file, creates the user commands, and stores them in
+ * the given data structure. Returns 1 on success, or -1 (with an appropriate
+ * error message set in the plugin) on error. */
+int parse_file(struct plugin_handle* plugin, struct ucmd_data* data, const char* filename)
+{
+	/* Create the parser state. */
+	struct parse_state* state = (struct parse_state*)hub_malloc(sizeof(struct parse_state));
+	state->plugin = plugin;
+	state->data = data;
+	state->ucmd = NULL;
+	state->credentials = auth_cred_none;
+	state->actions = 0;
+
+	/* Try to parse the file line by line. */
+	int retval = file_read_lines(filename, (void*)state, &parse_line);
+
+	/* Default error message. This probably means the file doesn't exist or we
+	 * do not have permission to open it - our parsing functions all set error
+	 * messages. */
+	if(retval < 0 && plugin->error_msg == NULL) plugin->error_msg = "Could not load user commands from file.";
+
+	/* Success; the final command needs to be added to the linked list. */
+	if(retval > 0 && state->ucmd != NULL)
+	{
+		if(state->actions)
+		{
+			add_command(data, state->ucmd, state->credentials);
+			state->ucmd = NULL;
+		}
+		else{
+			plugin->error_msg = "A command needs at least one action to perform.";
+			retval = -1;
+		}
+	}
+
+	/* Clean up memory from the state. If ucmd is not null, then there was an
+	 * error and it is a partially-processed object we also need to free. */
+	if(state->ucmd != NULL) plugin->hub.ucmd_free(plugin, state->ucmd);
+	hub_free(state);
+
+	/* Done. */
+	return retval;
+}
+
+/* Parse the configuration the plugin was started with and save the
+ * corresponding ucmd_data structure in the plugin structure. Returns 1 on
+ * success or -1 (with an appropriate error message set) on failure. */
+int parse_config(struct plugin_handle* plugin, const char* config)
+{
+	int got_file = 0;
+
+	/* Create space for the data we need. */
+	struct ucmd_data *data = (struct ucmd_data *)hub_malloc(sizeof(struct ucmd_data));
+	if(data == NULL){
+		plugin->error_msg = "Could not allocate data storage.";
+		return -1;
+	}
+
+	/* Initialise the linked lists for the commands. */
+	int i;
+	for(i = 0; i < auth_cred_admin; i++)
+	{
+		data->commands[i] = list_create();
+		if(data->commands[i] == NULL)
+		{
+			/* We cannot call the free_data() function here as not all the
+			 * lists have been initialised. */
+			int j;
+			for(j = 0; j < i; j++) list_destroy(data->commands[j]);
+			hub_free(data);
+			plugin->error_msg = "Could not allocate data storage.";
+			return -1;
+		}
+	}
+
+	/* Tokenize the config file and loop over each token. */
+	struct cfg_tokens* tokens = cfg_tokenize(config);
+	char* token = cfg_token_get_first(tokens);
+	while(token)
+	{
+		/* Try to split the setting into key and value. */
+		struct cfg_settings* setting = cfg_settings_split(token);
+		if(!setting)
+		{
+			plugin->error_msg = "Unable to parse plugin config";
+			cfg_tokens_free(tokens);
+			free_data(plugin, data);
+			return -1;
+		}
+		const char* key = cfg_settings_get_key(setting);
+		const char* value = cfg_settings_get_value(setting);
+
+		/* Name of file containing user commands. */
+		if (strncmp(key, "file", 4) == 0)
+		{
+			got_file = 1;
+			if(parse_file(plugin, data, value) < 0)
+			{
+				cfg_settings_free(setting);
+				cfg_tokens_free(tokens);
+				free_data(plugin, data);
+				return -1;
+			}
+		}
+
+		/* Unknown setting. */
+		else
+		{
+			plugin->error_msg = "Unknown setting when parsing plugin config";
+			cfg_settings_free(setting);
+			cfg_tokens_free(tokens);
+			free_data(plugin, data);
+			return -1;
+		}
+
+		/* Move onto next token. */
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+	cfg_tokens_free(tokens);
+
+	/* Make sure we were given at least one user command file. */
+	if(!got_file)
+	{
+		plugin->error_msg = "No command file given, use file=<filename>";
+		free_data(plugin, data);
+		return -1;
+	}
+
+	/* Save the data with the plugin and we're done. */
+	plugin->ptr = (void *)data;
+	return 1;
+}
+
+/* Attempt to load the plugin. Called by the hub when appropriate. */
+int plugin_register(struct plugin_handle *plugin, const char *config){
+	PLUGIN_INITIALIZE(plugin, "User command plugin", "0.1", "Provide custom commands to users.");
+
+	/* Attempt to parse the config we were given. */
+	if(parse_config(plugin, config) == -1) return -1;
+
+	/* Register our callbacks. */
+	plugin->funcs.on_user_login = on_user_login;
+
+	/* Done. */
+	return 0;
+}
+
+/* Unload the plugin. Called by the hub when appropriate. */
+int plugin_unregister(struct plugin_handle *plugin){
+	free_data(plugin, (struct ucmd_data *)plugin->ptr);
+	return 0;
+}
diff --git a/src/uhub.h b/src/uhub.h
index d5fc0f7..57d527e 100644
--- a/src/uhub.h
+++ b/src/uhub.h
@@ -95,6 +95,7 @@ extern "C" {
 #include "core/plugincallback.h"
 #include "core/plugininvoke.h"
 #include "core/pluginloader.h"
+#include "core/pluginucmd.h"