Index: binaries/data/mods/public/gui/common/moderation/LookupTables.js
===================================================================
--- binaries/data/mods/public/gui/common/moderation/LookupTables.js
+++ binaries/data/mods/public/gui/common/moderation/LookupTables.js
@@ -0,0 +1,75 @@
+// NOTE: Ensure that these lookup tables copied from NetModerationTables.h
+// are kept in sync with the C++ engine
+
+// Also ensure that code that uses these constants is executed after
+// the constants are defined.
+
+// enum class ModerationAction
+const ModerationAction =
+{
+	KICK: 1,
+	BAN: 2,
+	KICK_BAN: 3,
+	MUTE: 4,
+	HELPER: 5,
+	UNBAN: 6,
+	UNMUTE: 7,
+	UNHELPER: 8,
+	LIST_BAN: 9,
+	LIST_MUTE: 10,
+	LIST_HELPER: 11
+};
+
+// enum class ModerationResponseType
+const ModerationResponseType =
+{
+	// No responses, except admin notification of actions by helpers
+	SILENT: 0,
+	// Admin notification of actions by helpers, and error messages
+	INFO: 1,
+	// Broadcast announcements of successful effects of commands except list requests
+	ANNOUNCEMENT: 2,
+};
+
+// enum class ModerationResponseCode
+const ModerationResponseCode =
+{
+	UNUSED: 0,
+	FAILED: 1,
+	SUCCESS: 2,
+	PERMISSION_DENIED: 3,
+	IDENTIFIER_NOT_ON_SERVER: 4,
+	IDENTIFIER_NOT_IN_LIST: 5,
+	IDENTIFIER_ALREADY_IN_LIST: 6,
+	CANNOT_RESTRICT_HOST: 7,
+	SYNTAX_ERROR: 8,
+	CAPACITY_EXCEEDED: 9,
+	INSUFFICIENT_FILLER_DATA: 10,
+	LIST: 11
+};
+
+// enum class ModerationEffectType
+const ModerationEffectType =
+{
+	IP: 1,
+	USERNAME: 2,
+	USERNAME_AND_IP: 3
+};
+
+// enum class ModerationIdentifierType
+const ModerationIdentifierType =
+{
+	UNUSED: 0,
+	IP: 1,
+	USERNAME_PRESENT: 2,
+	USERNAME_NOT_PRESENT: 3,
+	USERNAME_IN_LIST_REGEX: 4,
+	USERNAME_COMMAND_ISSUER: 5,
+	GUID: 6
+};
+
+deepfreeze(ModerationAction);
+deepfreeze(ModerationResponseType);
+deepfreeze(ModerationResponseCode);
+deepfreeze(ModerationEffectType);
+deepfreeze(ModerationIdentifierType);
Index: binaries/data/mods/public/gui/common/moderation/ModerationResponseAnnouncementStringifier.js
===================================================================
--- binaries/data/mods/public/gui/common/moderation/ModerationResponseAnnouncementStringifier.js
+++ binaries/data/mods/public/gui/common/moderation/ModerationResponseAnnouncementStringifier.js
@@ -0,0 +1,43 @@
+class ModerationResponseAnnouncementStringifier
+{
+	constructor() {}
+
+	output(action, responseCode, effectType, username, ip, commandIssuer)
+	{
+		let outputFormatString;
+
+		if (responseCode === ModerationResponseCode.SUCCESS)
+		{
+			if (username.length > 0)
+				outputFormatString = this.detailedOutput[action];
+			if (outputFormatString !== undefined)
+			{
+				return sprintf(outputFormatString,
+				{
+					"username": username,
+				});
+			}
+			
+		}
+		return "";
+	}
+}
+
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput = {};
+
+// Translation: The user has been removed from the game
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.KICK] = translateWithContext("moderation", "%(username)s has been kicked");
+// Translation: The user has been removed from the game and added to the ban list
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.KICK_BAN] = translateWithContext("moderation", "%(username)s has been kicked and banned");
+// Translation: The user has been added to the ban list, and will not be allowed to reconnect to the server.
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.BAN] = translateWithContext("moderation", "%(username)s has been banned");
+// Translation: The user has been removed from the ban list, and will be allowed to reconnect to the server
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.UNBAN] = translateWithContext("moderation", "%(username)s has been unbanned");
+// Translation: The user is not allowed to send messages
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.MUTE] = translateWithContext("moderation", "%(username)s has been muted");
+// Translation: The user is allowed to send messages
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.UNMUTE] = translateWithContext("moderation", "%(username)s has been unmuted");
+// Translation: The user has been designated a moderation helper
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.HELPER] = translateWithContext("moderation", "%(username)s has been added to the list of helpers");
+// Translation: The user has lost the moderation helper status
+ModerationResponseAnnouncementStringifier.prototype.detailedOutput[ModerationAction.UNHELPER] = translateWithContext("moderation", "%(username)s has been removed from the list of helpers");
Index: binaries/data/mods/public/gui/common/moderation/ModerationResponseDecoder.js
===================================================================
--- binaries/data/mods/public/gui/common/moderation/ModerationResponseDecoder.js
+++ binaries/data/mods/public/gui/common/moderation/ModerationResponseDecoder.js
@@ -0,0 +1,245 @@
+class ModerationResponseDecoder
+{
+	ModerationResponseInfoStringifier = new ModerationResponseInfoStringifier();
+	ModerationResponseAnnouncementStringifier = new ModerationResponseAnnouncementStringifier();
+
+	constructor()
+	{
+	}
+
+	decode(action, responseType, responseCode, effectType, identifiers)
+	{
+		// Since there are many cases to address, we apply the strategy of
+		// narrowing them down as quickly as possible, based on the input
+
+		// Check for an unused response or a command mistakenly sent
+		// as a moderation response
+		if (responseCode === ModerationResponseCode.UNUSED)
+		{
+			error("BUG: A moderation response was received, but the response was marked as unused.");
+			return "";
+		}
+
+		// If we have received a moderation response when the requested
+		// moderation type was silent then don't produce output
+		if (responseType === ModerationResponseType.SILENT)
+			// return "DEBUG: (2) Moderation response was blank. This could be normal depending on the input.";
+			return "";
+
+		// Announcements must only be successful actions that are not
+		// responses to requests for the contents of lists
+		if (responseType === ModerationResponseType.ANNOUNCEMENT && !(responseCode === ModerationResponseCode.SUCCESS))
+			// return "DEBUG: (3) Moderation response was blank. This could be normal depending on the input.";
+			return "";
+
+		let text = "";
+
+		// Retrieve the identifiers. So far we will only use the last listed
+		// identifier of each of three types: username, ip and commandIssuerName
+		let hashresult = this.makeStringsFromIdentifiersHash(identifiers, false);
+		let username = hashresult['username'];
+		let ip = escapeText(hashresult['ip']);
+		let commandIssuerName = escapeText(hashresult['commandissuer']);
+		let guid = hashresult['guid'];
+
+		// Try to colorize the player name. This is a modified copy of
+		// colorizePlayerNameHelper that does not replace the player name with
+		// "(Unknown player)"
+		// Note that this relies on the caller replacing the global callback
+		// colorizePlayernameByGUID() with an appropriate function for the chat panel.
+		// See gui/common/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatMessages/ClientChat.js::colorizePlayernameByGUID()
+		// and gui/common/session/messages.js::colorizePlayernameByGUID()
+		if (username !== "")
+		{
+			if (guid !== "")
+			{
+				let theUsername = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].name : "";
+				if (theUsername.toLowerCase() === username.toLowerCase())
+				{
+					let thePlayerID = g_PlayerAssignments[guid] ? g_PlayerAssignments[guid].player : -1;
+					if (thePlayerID > 1)
+					{
+						username = colorizePlayernameByGUID(guid);
+					}
+					else
+						username = escapeText(username);
+				}
+				else
+					username = escapeText(username);
+			}
+			else
+				username = escapeText(username);
+		}
+
+		if (responseType === ModerationResponseType.ANNOUNCEMENT && username === "")
+			// No point to processing further since we won't be announcing IP addresses
+			// return "DEBUG: (5) Moderation announcement was blank. This could be normal depending on the input.";
+			return "";
+
+
+		// Process the simple cases first: successful completion of a command
+		// that doesn't involve retrieving a list and doesn't involve
+		// reporting the name of the command issuer
+		text = "";
+		let listName = "";
+		if (username !== "" && responseCode === ModerationResponseCode.SUCCESS &&
+		    (responseType === ModerationResponseType.ANNOUNCEMENT ||
+		    (responseType === ModerationResponseType.INFO &&
+		    commandIssuerName === "")))
+		{
+			text = this.ModerationResponseAnnouncementStringifier.output(action, responseCode, effectType, username, ip, commandIssuerName);
+		}
+
+		// From here on, the only response type allowed is INFO, as it's
+		// intended for admins to get more detailed successful command
+		// completion notices. This includes IP addresses, command issuer
+		// names, list output and error messages
+		if (text === "" && responseType === ModerationResponseType.INFO)
+		{
+			// Process list output
+			if (text === "")
+			{
+				let listTitle = "";
+				switch (action)
+				{
+				case ModerationAction.LIST_BAN:
+					// Translation: The list title is a label for the list of users in a moderation list, and it will be inserted where %(listtitle)s is present. In this case the users are disallowed from reconnecting to the server.
+					listTitle = translateWithContext("moderation", "Ban list");
+					break;
+				case ModerationAction.LIST_MUTE:
+					// Translation: The list title is a label for the list of users in a moderation list, and it will be inserted where %(listtitle)s is present. In this case the users are disallowed from sending messages.
+					listTitle = translateWithContext("moderation", "Mute list");
+					break;
+				case ModerationAction.LIST_HELPER:
+					// Translation: The list title is a label for the list of users in a moderation list, and it will be inserted where %(listtitle)s is present. In this case the users are designated as moderation helpers.
+					listTitle = translateWithContext("moderation", "Helper list");
+					break;
+				default:
+					break;
+				}
+				if (listTitle !== "" && (responseCode === ModerationResponseCode.SUCCESS || responseCode === ModerationResponseCode.LIST))
+				{
+					// Retrieve all of the identifiers for list output
+					// TODO: Use internationalized list separator character instead of comma
+					hashresult = this.makeStringsFromIdentifiersHash(identifiers, true);
+					// TODO: Offer an option to output a list in JSON format
+					if (hashresult !== undefined)
+					{
+						if (hashresult['username'].length > 0 && hashresult['ip'].length > 0)
+						{
+							// Translation: The contents of a moderation list are being output. There are one or more usernames and ip addresses, separated by commas
+							text = sprintf(translateWithContext("moderation", "%(listtitle)s: Users: %(usernames)s ; IPs: %(ipaddresses)s"),
+							{
+								"listtitle": listTitle,
+								"usernames": hashresult['username'],
+								"ipaddresses": hashresult['ip']
+							});
+						}
+						else if (hashresult['username'].length > 0)
+						{
+							// Translation: The contents of a moderation list are being output. There are one or more usernames, separated by commas
+							text = sprintf(translateWithContext("moderation", "%(listtitle)s: Users: %(usernames)s"),
+							{
+								"listtitle": listTitle,
+								"usernames": hashresult['username']
+							});
+						}
+						else if (hashresult['ip'].length > 0)
+						{
+							// Translation: The contents of a moderation list are being output. There are one or more IP addresses, separated by commas
+							text = sprintf(translateWithContext("moderation", "%(listtitle)s: IPs: %(ipaddresses)s"),
+							{
+								"listtitle": listTitle,
+								"ipaddresses": hashresult['ip']
+							});
+						}
+					}
+				}
+				else
+				{
+					text = this.ModerationResponseInfoStringifier.output(action, responseCode, effectType, username, ip, commandIssuerName);
+				}
+			}
+		}
+		// if (text === "")
+		// 	text = "DEBUG: (6) Moderation response was blank. This could be normal depending on the input.";
+		return text;
+	}
+
+	/**
+	 * Iterate through every element of the identifiers hash to extract usernames
+	 * and ip addresses
+	 * @return If mode is true, return a string with a list of identifiers.
+	 *          If mode is false, return a hash of one username and one ip (the
+	 *          first ones encountered)
+	 */
+	makeStringsFromIdentifiersHash(identifiers, mode)
+	{
+		let username = "";
+		let usernames = "";
+		let ip = "";
+		let ips = "";
+		let commandIssuerName = "";
+		let guid = "";
+		let identifierSize = 0;
+		if (identifiers !== undefined)
+		{
+			let firstusername = true;
+			let firstip = true;
+			let i = 0;
+			for (let x in identifiers)
+			{
+				if (identifiers[x] !== undefined)
+					switch (identifiers[x]['identifierType'])
+					{
+					case ModerationIdentifierType.USERNAME_PRESENT:
+					case ModerationIdentifierType.USERNAME_NOT_PRESENT:
+						if (username === "")
+							username = identifiers[x]['identifier'];
+						if (mode)
+						{
+							if (!firstusername)
+								usernames += translateWithContext("enumeration", ", ");
+							usernames += identifiers[x]['identifier'];
+							firstusername = false;
+						}
+						break;
+					case ModerationIdentifierType.IP:
+						if (ip === "")
+							ip = identifiers[x]['identifier'];
+						if (mode)
+						{
+							if (!firstip)
+								ips += translateWithContext("enumeration", ", ");
+							ips += identifiers[x]['identifier'];
+							firstip = false;
+						}
+						break;
+					case ModerationIdentifierType.USERNAME_COMMAND_ISSUER:
+						if (commandIssuerName === "")
+							commandIssuerName = identifiers[x]['identifier'];
+						break;
+					case ModerationIdentifierType.GUID:
+						if (guid === "")
+							guid = identifiers[x]['identifier'];
+						break;
+					default:
+						break;
+					}
+
+				++i;
+			}
+			identifierSize = i;
+		}
+
+		let thehashresult =
+		{
+			'username': mode ? usernames : username,
+			'ip': mode ? ips : ip,
+			'commandissuer': commandIssuerName,
+			'guid': guid
+		}
+		return thehashresult;
+	}
+}
+
Index: binaries/data/mods/public/gui/common/moderation/ModerationResponseInfoStringifier.js
===================================================================
--- binaries/data/mods/public/gui/common/moderation/ModerationResponseInfoStringifier.js
+++ binaries/data/mods/public/gui/common/moderation/ModerationResponseInfoStringifier.js
@@ -0,0 +1,107 @@
+class ModerationResponseInfoStringifier
+{
+	constructor()
+	{
+	}
+
+
+	output(action, responseCode, effectType, username, ip, commandIssuer)
+	{
+		// Translation: This is a noun that describes a missing or non-applicable username. It will be inserted in a response to a moderation command at %(username)s
+		username = username.length > 0 ? username : translateWithContext("moderation", "(no username)");
+		// Translation: This is a noun that describes a missing or non-applicable IP address. It will be inserted in a response to a moderation command at %(ipaddress)s
+		ip = ip.length > 0 ? ip : translateWithContext("moderation", "(no IP)");
+		// Translation: This is a noun that describes the user that issued the moderation command. In this case it is the person who is hosting the game. The noun will be inserted in a response to a moderation command at %(commandIssuer)s
+		commandIssuer = commandIssuer.length > 0 ? commandIssuer : translateWithContext("moderation", "(host)");
+
+		let outputFormatString;
+
+		if (responseCode === ModerationResponseCode.SUCCESS)
+		{
+			if (username.length > 0 || ip.length > 0)
+				outputFormatString = this.detailedOutput[action];
+			if (outputFormatString !== undefined)
+			{
+				let effectString = this.effectOutput[effectType];
+				if (effectString === undefined)
+				{
+					error("BUG: Unknown effect type in moderation response");
+					// Translation: effectString is a noun that describes the types of identifiers (e.g. usernames or IP addresses) that are affected by a moderation action. In this case the effect is unknown.
+					effectString = translateWithContext("moderation", "unknown effect");
+				}
+
+				return sprintf(outputFormatString,
+				{
+					"username": username,
+					"ipaddress": ip,
+					"effect": effectString,
+					"commandissuer": commandIssuer
+				});
+			}
+
+			return this.genericOutput[ModerationResponseCode.SUCCESS];
+		}
+		else
+		{
+			outputFormatString = this.genericOutput[responseCode];
+			if (outputFormatString !== undefined)
+				return outputFormatString;
+
+			error("BUG: Unknown moderation response.");
+			return "";
+		}
+	}
+}
+
+ModerationResponseInfoStringifier.prototype.detailedOutput = {};
+
+// Translation: The user has been removed from the game
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.KICK] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been kicked by %(commandissuer)s");
+// Translation: The user has been removed from the game and added to the ban list
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.KICK_BAN] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been kicked and banned by %(commandissuer)s");
+// Translation: The user has been added to the ban list, and will not be allowed to reconnect to the server.
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.BAN] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been banned by %(commandissuer)s");
+// Translation: The user has been removed from the ban list, and will be allowed to reconnect to the server
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.UNBAN] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been unbanned by %(commandissuer)s");
+// Translation: The user is not allowed to send messages
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.MUTE] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been muted by %(commandissuer)s");
+// Translation: The user is allowed to send messages
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.UNMUTE] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been unmuted by %(commandissuer)s");
+// Translation: The user has been designated a moderation helper
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.HELPER] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been added to the list of helpers by %(commandissuer)s");
+// Translation: The user has lost the moderation helper status
+ModerationResponseInfoStringifier.prototype.detailedOutput[ModerationAction.UNHELPER] = translateWithContext("moderation", "%(username)s and IP %(ipaddress)s, with effect on %(effect)s, have been removed from the list of helpers by %(commandissuer)s");
+
+ModerationResponseInfoStringifier.prototype.genericOutput = {};
+
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.UNUSED] = "";
+// Translation: The moderation command, such as kick or ban, was unsuccessful
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.FAILED] = translateWithContext("moderation", "Error: The command failed.");
+// Translation: The moderation command, such as kick or ban, was successful
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.SUCCESS] = translateWithContext("moderation", "The command was successful.");
+// Translation: The command issuer does not have permission to issue the moderation command
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.PERMISSION_DENIED] = translateWithContext("moderation", "Error: Permission denied.");
+// Translation: The moderation command was unsuccessful because the identifier (for example username or IP address) was not found on the server
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.IDENTIFIER_NOT_ON_SERVER] = translateWithContext("moderation", "Error: The command could not be completed. The identifier was not found on the server.");
+// Translation: The moderation command was unsuccessful because the identifier (for example username or IP address) was not found in the moderation list
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.IDENTIFIER_NOT_IN_LIST] = translateWithContext("moderation", "Error: The command could not be completed. The identifier was not found in the list.");
+// Translation: The moderation command was unsuccessful because the identifier (for example username or IP address) is already present in the moderation list
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.IDENTIFIER_ALREADY_IN_LIST] = translateWithContext("moderation", "Error: The command could not be completed. The identifier is already in the list.");
+// Translation: The moderation command was unsuccessful because it would place a restriction on the user that is hosting the game
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.CANNOT_RESTRICT_HOST] = translateWithContext("moderation", "Error: The command could not be completed. Cannot restrict the host.");
+// Translation: The moderation command was unsuccessful because the command was not entered correctly, or the requested effects are not available
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.SYNTAX_ERROR] = translateWithContext("moderation", "Error: Syntax error or unimplemented combination of identifier type and effect type");
+// Translation: The moderation command was unsuccessful because a moderation list memory usage, moderation list element count, or amount of network data transfer would exceed certain limits that have been established. The purpose of these limits is to maintain performance and reliability of the software
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.CAPACITY_EXCEEDED] = translateWithContext("moderation", "Error: A capacity limit would be exceeded if the command was processed");
+// Translation: The moderation command was unsuccessful because the command sender did not include enough filler (unused) data in the request compared to the size of the expected response. This is intended to prevent network request amplification of moderation list output.
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.INSUFFICIENT_FILLER_DATA] = translateWithContext("moderation", "Error: Insufficient filler data provided.");
+ModerationResponseInfoStringifier.prototype.genericOutput[ModerationResponseCode.LIST] = "";
+
+ModerationResponseInfoStringifier.prototype.effectOutput = {};
+
+// Translation: This is a noun that describes the effect of a moderation command. In this case it is an IP address.
+ModerationResponseInfoStringifier.prototype.effectOutput[ModerationEffectType.IP] = translateWithContext("moderation", "IP address");
+// Translation: This is a noun that describes the effect of a moderation command. In this case it is the name of a user
+ModerationResponseInfoStringifier.prototype.effectOutput[ModerationEffectType.USERNAME] = translateWithContext("moderation", "username");
+// Translation: This is a noun that describes the effect of a moderation command. In this case it is the name of a user and an IP address
+ModerationResponseInfoStringifier.prototype.effectOutput[ModerationEffectType.USERNAME_AND_IP] = translateWithContext("moderation", "username and IP address");
Index: binaries/data/mods/public/gui/common/moderation/send_moderation_command.js
===================================================================
--- binaries/data/mods/public/gui/common/moderation/send_moderation_command.js
+++ binaries/data/mods/public/gui/common/moderation/send_moderation_command.js
@@ -0,0 +1,302 @@
+var g_NetworkCommands = {
+	"/ban-ni": argument => moderation(ModerationAction.KICK_BAN, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/ban-n": argument => moderation(ModerationAction.BAN, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/ban-i": argument => moderation(ModerationAction.BAN, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/kick": argument => moderation(ModerationAction.KICK, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/kick-ni": argument => moderation(ModerationAction.KICK, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/kick-n": argument => moderation(ModerationAction.KICK, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/kickban-ni": argument => moderation(ModerationAction.KICK_BAN, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/kickban-n": argument => moderation(ModerationAction.KICK_BAN, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/mute-ni": argument => moderation(ModerationAction.MUTE, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/mute-n": argument => moderation(ModerationAction.MUTE, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/mute-i": argument => moderation(ModerationAction.MUTE, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/helper-ni": argument => moderation(ModerationAction.HELPER, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_PRESENT, argument),
+	"/helper-i": argument => moderation(ModerationAction.HELPER, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/helper-n": argument => moderation(ModerationAction.HELPER, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/unban-n": argument => moderation(ModerationAction.UNBAN, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/unban-i": argument => moderation(ModerationAction.UNBAN, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/unmute-n": argument => moderation(ModerationAction.UNMUTE, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/unmute-i": argument => moderation(ModerationAction.UNMUTE, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/unhelper-n": argument => moderation(ModerationAction.UNHELPER, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/unhelper-i": argument => moderation(ModerationAction.UNHELPER, -1, ModerationEffectType.IP, ModerationIdentifierType.IP, argument),
+	"/listban": argument => moderation(ModerationAction.LIST_BAN, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/listmute": argument => moderation(ModerationAction.LIST_MUTE, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/listhelper": argument => moderation(ModerationAction.LIST_HELPER, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_NOT_PRESENT, argument),
+	"/help": argument => moderationHelp(),
+	"/kickspecs": argument => kickObservers(false),
+	"/banspecs": argument => kickObservers(true),
+	"/list": argument => g_callbackAddChatText({ "type": "clientlist" }),
+	"/listusers": argument => g_callbackAddChatText({ "type": "clientlist" }),
+	"/clear": argument => clearChatMessages()
+};
+
+// Function pointer for adding chat text to the chat window. This is GUI and class-dependent
+function g_callbackAddChatText()
+{
+	// This is replaced with an actual function by calling executeNetworkCommand() with the appropriate argument
+};
+
+function kickPlayer(username, ban)
+{
+	if (!ban)
+		moderation(ModerationAction.KICK, -1, ModerationEffectType.USERNAME, ModerationIdentifierType.USERNAME_PRESENT, username);
+	else
+		moderation(ModerationAction.KICK_BAN, -1, ModerationEffectType.USERNAME_AND_IP, ModerationIdentifierType.USERNAME_PRESENT, username);
+}
+
+function kickObservers(ban)
+{
+	for (let guid in g_PlayerAssignments)
+		if (g_PlayerAssignments[guid].player == -1)
+			kickPlayer(g_PlayerAssignments[guid].name, ban);
+}
+
+function moderationHelp()
+{
+	// Help was requested. Send moderation responses with the syntax of the moderation commands
+	g_callbackAddChatText({
+		"type": "moderationresponse",
+		"text": escapeText("Syntax: /[list|clear]")
+	});
+	if (!g_IsController)
+	{
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Syntax: (for moderation helpers) /[listmute]")
+		});
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Syntax: (for moderation helpers) /[mute-n|unmute-n] username")
+		});
+	}
+	else  /* g_IsController */
+	{
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Syntax: /[listban|listmute|listhelper|kickspecs|banspecs]")
+		});
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Syntax: /[kick|ban|unban|mute|unmute|helper|unhelper](-ni|-n|-i) (identifier)")
+		});
+	}
+	g_callbackAddChatText({
+		"type": "moderationresponse",
+		"text": escapeText("Note 1: Helpers can only work with usernames that are present on the server.")
+	});
+	g_callbackAddChatText({
+		"type": "moderationresponse",
+		"text": escapeText("Note 2: After a username is (optionally) checked for presence on the server, it is converted to lowercase with no rating for storage or comparison with list contents.")
+	});
+	if (g_IsController)
+	{
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Note 3: The -n variant of each command has effect on name only, and does not require the user to be present (except see note above about Moderation Helpers). The -i variant has effect on the supplied IP only. The -ni variant has effect on name and IP, and requires the identified user to be present on the server.")
+		});
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("Example (this adds the name and IP of the user to the ban list and then kicks the user): /kickban-ni JohnDoe")
+		});
+	}
+	g_callbackAddChatText({
+		"type": "moderationresponse",
+		"text": escapeText("Example (this adds the name, which doesn't need to be present, to the mute list): /mute-n disruptive_dude (customRating)")
+	});
+	return false;
+}
+
+// Returns: true if a command other than help or list was successful
+//          false, otherwise
+function moderation(action, responseType, effectType, identifierType, identifier)
+{
+	// Permission to use moderation commands depends on more than just
+	// whether the client is the controller of the game. There are lobby
+	// helpers with mute capability. Permissions are enforced by the
+	// server.
+
+	let result = false;
+
+
+	/*
+	// If effectType is unset then for the controller default to effectType
+	// both for certain actions, otherwise default to effectType username
+	if (effectType === -1)
+	{
+		if (g_IsController)
+		{
+			if (action === ModerationAction.BAN ||
+			    action === ModerationAction.KICK_BAN ||
+			    action === ModerationAction.LIST_BAN ||
+			    action === ModerationAction.LIST_MUTE ||
+			    action === ModerationAction.LIST_HELPER)
+				effectType = ModerationEffectType.USERNAME_AND_IP;
+			else
+				effectType = ModerationEffectType.USERNAME;
+		}
+		else
+			effectType = ModerationEffectType.USERNAME;
+	}
+	*/
+
+	// Non-controllers can only operate on usernames and users that are present
+	if (!g_IsController)
+	{
+		if (effectType === ModerationEffectType.USERNAME_AND_IP)
+			effectType = ModerationEffectType.USERNAME;
+		if (identifierType === ModerationIdentifierType.USERNAME_NOT_PRESENT)
+			identifierType = ModerationIdentifierType.USERNAME_PRESENT;
+	}
+
+	if (responseType === -1)
+	{
+		if (action === ModerationAction.LIST_BAN ||
+		    action === ModerationAction.LIST_MUTE ||
+		    action === ModerationAction.LIST_HELPER)
+			// The only allowed response type for list or help is info only
+			responseType = ModerationResponseType.INFO;
+		else
+			// The default response type for other commands is info and announcement
+			responseType = ModerationResponseType.ANNOUNCEMENT;
+	}
+
+	let identifiers = {};
+
+	identifiers['0'] =
+	{
+		"identifierType": identifierType,
+		"identifier": identifier
+	};
+
+	// Ensure that there is an argument for all commands except help and those that output the contents of lists
+	if ((action === ModerationAction.LIST_BAN ||
+	    action === ModerationAction.LIST_MUTE) ||
+	    action === ModerationAction.LIST_HELPER ||
+	    (identifiers !== undefined && Object.keys(identifiers).length > 0))
+	{
+		// Check if the client is the game controller or else the
+		// commands are allowed by users in the 'helpers' list. The
+		// engine will enforce the permissions properly
+		if (g_IsController || ((identifierType === ModerationIdentifierType.USERNAME_PRESENT ||
+		    identifierType === ModerationIdentifierType.USERNAME_NOT_PRESENT) &&
+		    (effectType === ModerationEffectType.USERNAME) &&
+		    (action === ModerationAction.MUTE || action === ModerationAction.UNMUTE ||
+		    action === ModerationAction.LIST_MUTE)))
+		{
+			// Send the message to the server to perform the actual moderation action
+			let moderationIdentifierContainer = { };
+			Object.defineProperty(moderationIdentifierContainer, "identifiers", {
+				"value": deepfreeze(identifiers)
+			});
+			/*
+			// For debugging, locally output the identifiers that will be sent
+			let str = JSON.stringify(identifiers, null, 2);
+			g_callbackAddChatText({
+				"type": "moderationresponse",
+				"text": escapeText(sprintf("%s", str))
+			});
+			*/
+			Engine.Moderation(action, 1 /* true */, responseType, ModerationResponseCode.UNUSED,
+			                  effectType, moderationIdentifierContainer.identifiers);
+		}
+		else
+		{
+			moderationPermissionError();
+			return false;
+		}
+
+	}
+	else
+	{
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			// Translation: The moderation command was unsuccessful because the command was not entered correctly, or the requested effects are not available
+			"text": escapeText(translateWithContext("moderation", "Error: Syntax error or unimplemented combination of identifier type and effect type"))
+		});
+	}
+}
+
+function moderationPermissionError()
+{
+	g_callbackAddChatText({
+		"type": "moderationresponse",
+		// Translation: The command issuer does not have permission to issue the moderation command
+		"text": escapeText(translateWithContext("moderation", "Error: Permission denied."))
+	});
+}
+
+/**
+ * Execute a command locally.
+ *
+ * @param {string} input
+ * @param {function} callbackAddChatText - a function to add text to the chat
+ *                   messages panel
+ * @return {boolean} whether a command was executed
+ */
+function executeNetworkCommand(input, callbackAddChatText)
+{
+	if (!g_IsNetworked)
+		return false;
+	if (input.indexOf("/") != 0)
+	{
+		// No frontslash detected, so not a command. return false so
+		// that the message can be processed by the other handlers.
+		return false;
+	}
+
+	let command = input.split(" ", 1)[0];
+	let argument = input.substr(command.length + 1);
+	g_callbackAddChatText = callbackAddChatText;
+	switch (command)
+	{
+	case "/observers":
+	case "/allies":
+	case "/enemies":
+	case "/msg":
+	case "/me":
+		if (argument.indexOf("/") != 0)
+		{
+			// We don't handle chat-related commands here. Pass
+			// them on to the chat message sender
+			return false;
+		}
+		else
+		{
+			// A command was found after a special chat message.
+			// This is likely an administrator mistake, pressing T
+			// to start typing a command.
+			
+			g_callbackAddChatText({
+				"type": "moderationresponse",
+				// Translation: A command (signaled by a frontslash) was detected after another command. For safety, it was not sent as a chat message
+				"text": escapeText(translateWithContext("moderation", "A command was found after a chat command. It was not processed, and the chat message was not sent."))
+			});
+			return true;
+		}
+	default:
+		// Any other text starting with a frontslash should be consumed and not sent as a chat message.
+		// On second thought, let's return false and let the next handler handle it.
+		break;
+	}
+
+	if (!g_NetworkCommands[command])
+	{
+		// The command was not recognized as a moderation command. Pass it on to the other handlers
+		return false;
+	}
+	else
+	{
+		// Echo back the command that was typed by the user for easier editing
+		g_callbackAddChatText({
+			"type": "moderationresponse",
+			"text": escapeText("> " + input)
+		});
+		g_NetworkCommands[command](argument);
+	}
+
+	// The command was recognized as a moderation command. It either
+	// completed successfully or resulted in a syntax error. Indicate to
+	// the caller that the command was handled so that other handlers
+	// don't try to process it (such as sending it as a chat message).
+	return true;
+}
Index: binaries/data/mods/public/gui/common/network.js
===================================================================
--- binaries/data/mods/public/gui/common/network.js
+++ binaries/data/mods/public/gui/common/network.js
@@ -36,15 +36,6 @@
 		})
 };
 
-var g_NetworkCommands = {
-	"/kick": argument => kickPlayer(argument, false),
-	"/ban": argument => kickPlayer(argument, true),
-	"/kickspecs": argument => kickObservers(false),
-	"/banspecs": argument => kickObservers(true),
-	"/list": argument => addChatMessage({ "type": "clientlist" }),
-	"/clear": argument => clearChatMessages()
-};
-
 var g_ValidPorts = { "min": 1024, "max": 65535 };
 // TODO: This check should be performed exclusively on the C++ side, currently this is sort of redundant.
 function getValidPort(port)
@@ -102,35 +93,6 @@
 	);
 }
 
-function kickError()
-{
-	addChatMessage({
-		"type": "system",
-		"text": translate("Only the host can kick clients!")
-	});
-}
-
-function kickPlayer(username, ban)
-{
-	if (g_IsController)
-		Engine.KickPlayer(username, ban);
-	else
-		kickError();
-}
-
-function kickObservers(ban)
-{
-	if (!g_IsController)
-	{
-		kickError();
-		return;
-	}
-
-	for (let guid in g_PlayerAssignments)
-		if (g_PlayerAssignments[guid].player == -1)
-			Engine.KickPlayer(g_PlayerAssignments[guid].name, ban);
-}
-
 /**
  * Sort GUIDs of connected users sorted by playerindex, observers last.
  * Requires g_PlayerAssignments.
@@ -167,26 +129,6 @@
 }
 
 /**
- * Execute a command locally. Requires addChatMessage.
- *
- * @param {string} input
- * @returns {boolean} whether a command was executed
- */
-function executeNetworkCommand(input)
-{
-	if (input.indexOf("/") != 0)
-		return false;
-
-	let command = input.split(" ", 1)[0];
-	let argument = input.substr(command.length + 1);
-
-	if (g_NetworkCommands[command])
-		g_NetworkCommands[command](argument);
-
-	return !!g_NetworkCommands[command];
-}
-
-/**
  * Remember this warning for a few seconds.
  * Overwrite previous warnings for this user.
  *
Index: binaries/data/mods/public/gui/credits/texts/programming.json
===================================================================
--- binaries/data/mods/public/gui/credits/texts/programming.json
+++ binaries/data/mods/public/gui/credits/texts/programming.json
@@ -200,6 +200,7 @@
 				{ "nick": "nikagra", "name": "Mikita Hradovich" },
 				{ "nick": "njm" },
 				{ "nick": "NoMonkey", "name": "John Mena" },
+				{ "nick": "Norse_Harold" },
 				{ "nick": "norsnor" },
 				{ "nick": "notpete", "name": "Rich Cross" },
 				{ "nick": "Nullus" },
Index: binaries/data/mods/public/gui/gamesetup/NetMessages/NetMessages.js
===================================================================
--- binaries/data/mods/public/gui/gamesetup/NetMessages/NetMessages.js
+++ binaries/data/mods/public/gui/gamesetup/NetMessages/NetMessages.js
@@ -57,5 +57,6 @@
 	"netstatus",
 	"netwarn",
 	"players",
-	"start"
+	"start",
+	"moderation-response"
 ];
Index: binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatInputPanel.js
===================================================================
--- binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatInputPanel.js
+++ binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatInputPanel.js
@@ -1,8 +1,9 @@
 class ChatInputPanel
 {
-	constructor(netMessages, chatInputAutocomplete)
+	constructor(netMessages, chatInputAutocomplete, executeNetworkCommandInterface)
 	{
 		this.chatInputAutocomplete = chatInputAutocomplete;
+		this.executeNetworkCommandInterface = executeNetworkCommandInterface;
 
 		this.chatInput = Engine.GetGUIObjectByName("chatInput");
 		this.chatInput.tooltip = colorizeAutocompleteHotkey(this.Tooltip);
@@ -44,8 +45,20 @@
 
 		this.chatInput.caption = "";
 
-		if (!executeNetworkCommand(text))
+		if (text.startsWith('/'))
+		{
+			const cmd = text.split(/\s/)[0];
+			if (!this.executeNetworkCommandInterface(text))
+			{
+				// None of the chat commands are recognized in this chat window.
+				// Warn the user and don't send the command as a message.
+				warn("Unknown chat command: " + cmd);
+			}
+		}
+		else
+		{
 			Engine.SendNetworkChat(text);
+		}
 
 		this.chatInput.focus();
 	}
Index: binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatMessagesPanel.js
===================================================================
--- binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatMessagesPanel.js
+++ binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatMessagesPanel.js
@@ -35,6 +35,11 @@
 		this.chatText.addItem(text);
 	}
 
+	addMessageText(msg)
+	{
+		this.addText(msg.text);
+	}
+
 	addStatusMessage(text)
 	{
 		this.addText(this.statusMessageFormat.format(text));
Index: binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatPanel.js
===================================================================
--- binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatPanel.js
+++ binaries/data/mods/public/gui/gamesetup/Pages/GameSetupPage/Panels/Chat/ChatPanel.js
@@ -19,11 +19,72 @@
 		this.chatInputAutocomplete = new ChatInputAutocomplete(
 			gameSettingControlManager, setupWindow.controls.gameSettingsController, setupWindow.controls.playerAssignmentsController);
 
+		this.moderationResponseDecoder = new ModerationResponseDecoder();
+
+		// Pass a callback for executeNetworkCommand that is customized to use the appropriate callback for adding chat text to the messages panel
 		this.chatInputPanel = new ChatInputPanel(
-			setupWindow.controls.netMessages, this.chatInputAutocomplete);
+			setupWindow.controls.netMessages, this.chatInputAutocomplete, this.executeNetworkCommandInterface.bind(this));
 
 		this.chatMessageEvents = [];
 		for (let name in ChatMessageEvents)
 			this.chatMessageEvents.push(new ChatMessageEvents[name](setupWindow, this.chatMessagesPanel));
+		setupWindow.controls.netMessages.registerNetMessageHandler("moderation-response", this.onModerationResultMessage.bind(this));
+	}
+
+	executeNetworkCommandInterface(command)
+	{
+		return executeNetworkCommand(command, this.chatMessagesPanel.addMessageText.bind(this.chatMessagesPanel));
+	}
+
+	onModerationResultMessage(msg)
+	{
+		if (msg.responseCode != ModerationResponseCode.UNUSED && !msg.actionIsCommand)
+		{
+			// Convert the moderation response codes to a human-readable string of text for output in the chat message window
+			const text = this.moderationResponseDecoder.decode(msg.action, msg.responseType, msg.responseCode, msg.effectType, msg.identifiers);
+			// decode already applies escapeText to user-provided input.
+			// We don't want to escape the entire moderation response because that would
+			// disrupt colorization of player names
+			if (msg.responseType === ModerationResponseType.ANNOUNCEMENT)
+			{
+				// TODO: Format the message as a status message if it's an announcement so that
+				// it is uniform with join, leave and kick messages.
+				// However, this would need to be special-cased for gamesetup chat, because
+				// session chat has a different way of formatting kicked messages
+				// this.chatMessagesPanel.addStatusMessage
+				this.chatMessagesPanel.addMessageText({
+					"type": "moderationresponse",
+					"text": text
+				});
+			}
+			else if (msg.responseType === ModerationResponseType.INFO)
+			{
+				this.chatMessagesPanel.addMessageText({
+					"type": "moderationresponse",
+					"text": text
+				});
+			}
+			else
+			{
+				/*
+				let text = "DEBUG: Displaying a moderation response despite it not passing the filter: " + this.moderationResponseDecoder.decode(msg.action, msg.responseType, msg.responseCode, msg.effectType, msg.identifiers);
+					this.chatMessagesPanel.addMessageText({
+						"type": "moderationresponse",
+						"text": text
+					});
+				*/
+			}
+		}
+		else
+		{
+			/*
+			let text = "DEBUG: Displaying a moderation response despite it not passing the filter: " + this.moderationResponseDecoder.decode(msg.action, msg.responseType, msg.responseCode, msg.effectType, msg.identifiers);
+			text = escapeText(text);
+				this.chatMessagesPanel.addMessageText({
+					"type": "moderationresponse",
+					"text": text
+				});
+			*/
+		}
 	}
 }
Index: binaries/data/mods/public/gui/gamesetup/gamesetup.xml
===================================================================
--- binaries/data/mods/public/gui/gamesetup/gamesetup.xml
+++ binaries/data/mods/public/gui/gamesetup/gamesetup.xml
@@ -2,6 +2,7 @@
 <objects>
 
 	<script directory="gui/common/"/>
+	<script directory="gui/common/moderation/"/>
 	<script directory="gui/maps/"/>
 	<script directory="gamesettings/"/>
 	<script directory="gamesettings/attributes/"/>
Index: binaries/data/mods/public/gui/session/chat/Chat.js
===================================================================
--- binaries/data/mods/public/gui/session/chat/Chat.js
+++ binaries/data/mods/public/gui/session/chat/Chat.js
@@ -15,7 +15,10 @@
 		const alignmentHelper = new AlignmentHelper("max");
 
 		this.ChatInput = new ChatInput(alignmentHelper);
-		this.ChatInput.registerChatSubmitHandler(executeNetworkCommand);
+
+		// Pass a callback for executeNetworkCommand that is customized to use the appropriate callback for adding chat text to the messages panel
+		if (g_IsNetworked)
+			this.ChatInput.registerChatSubmitHandler(this.executeNetworkCommandInterface.bind(this));
 		this.ChatInput.registerChatSubmitHandler(cheats.executeCheat.bind(cheats));
 		this.ChatInput.registerChatSubmitHandler(this.submitChat.bind(this));
 		this.ChatInput.registerChatSubmittedHandler(this.closePage.bind(this));
@@ -78,6 +81,22 @@
 	}
 
 	/**
+	 * Execute the network command
+	 */
+	executeNetworkCommandInterface(text)
+	{
+		if (!g_IsNetworked)
+		{
+			return false;
+		}
+		// Pass the text and a function for adding text to the chat window
+		// Returns true if the message was handled, false if the
+		// message should be handled by the other handlers. Ensure
+		// that the return value is returned to the caller.
+		return executeNetworkCommand(text, addChatMessage);
+	}
+
+	/**
 	 * Send the given chat message.
 	 */
 	submitChat(text, command = "")
Index: binaries/data/mods/public/gui/session/chat/ChatMessageFormatNetwork.js
===================================================================
--- binaries/data/mods/public/gui/session/chat/ChatMessageFormatNetwork.js
+++ binaries/data/mods/public/gui/session/chat/ChatMessageFormatNetwork.js
@@ -60,6 +60,14 @@
 	}
 };
 
+ChatMessageFormatNetwork.moderationresponse = class
+{
+	parse(msg)
+	{
+		return { "text": msg.text };
+	}
+};
+
 ChatMessageFormatNetwork.rejoined = class
 {
 	parse(msg)
Index: binaries/data/mods/public/gui/session/chat/ChatMessageFormatPlayer.js
===================================================================
--- binaries/data/mods/public/gui/session/chat/ChatMessageFormatPlayer.js
+++ binaries/data/mods/public/gui/session/chat/ChatMessageFormatPlayer.js
@@ -86,6 +86,14 @@
 			msg.guid == Engine.GetPlayerGUID() :
 			senderID == Engine.GetPlayerID();
 
+		// Protect admins from ham-handing moderation commands and sending them over chat
+		if (msg.text.startsWith('/'))
+		{
+			if (isSender)
+				warn(escapeText(translate("A command was found after a chat command. It was not processed, and the chat message was not sent.")));
+			return false;
+		}
+
 		// Parse private message
 		let isPM = msg.cmd == "/msg";
 		let addresseeGUID;
Index: binaries/data/mods/public/gui/session/messages.js
===================================================================
--- binaries/data/mods/public/gui/session/messages.js
+++ binaries/data/mods/public/gui/session/messages.js
@@ -89,6 +89,22 @@
 			"banned": msg.banned
 		});
 	},
+	"moderation-response": msg => {
+		if (msg.responseCode !== ModerationResponseCode.UNUSED && !msg.actionIsCommand)
+		{
+			// Convert the moderation response codes to a human-readable string of text for output in the chat message window
+			const text = g_ModerationResponseDecoder.decode(msg.action, msg.responseType, msg.responseCode, msg.effectType, msg.identifiers);
+			if (msg.responseType === ModerationResponseType.ANNOUNCEMENT || msg.responseType === ModerationResponseType.INFO)
+			{
+				addChatMessage({
+				// TODO: Add the announcement as a status message
+				// addStatusMessage
+					"type": "moderationresponse",
+					"text": text
+				});
+			}
+		}
+	},
 	"chat": msg => {
 		addChatMessage({
 			"type": "message",
@@ -107,6 +123,8 @@
 
 var g_LastAttack;
 
+var g_ModerationResponseDecoder = new ModerationResponseDecoder();
+
 /**
  * Defines how the GUI reacts to notifications that are sent by the simulation.
  * Don't open new pages (message boxes) here! Otherwise further notifications
Index: binaries/data/mods/public/gui/session/session.xml
===================================================================
--- binaries/data/mods/public/gui/session/session.xml
+++ binaries/data/mods/public/gui/session/session.xml
@@ -4,6 +4,7 @@
 
 <script directory="gui/common/"/>
 <script directory="gui/common/campaigns/"/>
+<script directory="gui/common/moderation/"/>
 <script directory="gui/maps/"/>
 <script directory="gui/session/"/>
 <script directory="gui/session/campaigns/"/>
Index: binaries/data/mods/public/l10n/messages.json
===================================================================
--- binaries/data/mods/public/l10n/messages.json
+++ binaries/data/mods/public/l10n/messages.json
@@ -322,6 +322,7 @@
                 "filemasks": [
                     "globalscripts/**.js",
                     "gui/common/**.js",
+                    "gui/common/moderation/**.js",
                     "gui/credits/**.js",
                     "gui/hotkeys/**.js",
                     "gui/loadgame/**.js",
Index: source/lib/external_libraries/enet.h
===================================================================
--- source/lib/external_libraries/enet.h
+++ source/lib/external_libraries/enet.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -52,4 +52,15 @@
  has an incompatible API and network protocol. Please switch to a newer version.
 #endif
 
+#if defined(ENET_VERSION_MAJOR) && (ENET_VERSION_MAJOR > 1) || \
+          ((ENET_VERSION_MAJOR == 1) && ((ENET_VERSION_MINOR > 3) || \
+          ((ENET_VERSION_MINOR == 3) && (ENET_VERSION_PATCH >= 14))))
+#define ENET_HAVE_ENET_ADDRESS_SET_HOST_IP
+#else
+#if OS_WIN
+#error The game currently requires ENet 1.3.14 or higher on Windows. You are using an older version, which\
+ lacks the enet_address_set_host_ip function. Please switch to a newer version.
+#endif
+#endif
+
 #endif	// #ifndef INCLUDED_ENET
Index: source/network/NetClient.h
===================================================================
--- source/network/NetClient.h
+++ source/network/NetClient.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -21,6 +21,8 @@
 #include "network/FSM.h"
 #include "network/NetFileTransfer.h"
 #include "network/NetHost.h"
+#include "network/NetModerationTables.h"
+#include "network/NetMessage.h"
 #include "scriptinterface/Object.h"
 
 #include "ps/CStr.h"
@@ -250,6 +252,34 @@
 	void SendKickPlayerMessage(const CStrW& playerName, bool ban);
 
 	/**
+	 * Check and send a moderation message to kick, mute, ban, etc. a client
+	 */
+	void SendModerationMessage(CNetMessage *message);
+
+	/**
+	 * Fill a CModerationMessage with the field data in the arguments. Does not affect the list of identifiers
+	 * See CNetServerWorker::AddFieldsToModerationMessage() for the parameter documentation
+	 */
+	static void AddFieldsToModerationMessage(CNetMessage* message, const u8 action, const u8 actionIsCommand, const u8 responseType, const u8 responseCode, const u8 effectType);
+
+	/**
+	 * Add a single identifier to the end of the list of identifiers in a CModerationMessage.
+	 * See CNetServerWorker::AddFieldsToModerationMessage() for the parameter documentation
+	 */
+	static void AddIdentifierToModerationMessage(CNetMessage* message, const u8 identifierType, const CStrW& identifier);
+
+	/**
+	 * Fill a CModerationMessage with the default field data and empty identifiers list
+	 */
+	static void ResetModerationMessage(CNetMessage* message);
+
+	/**
+	 * Notify the GUI of a received moderation response so that it can be decoded
+	 * and notification of the results can be made to the user
+	 */
+	void PostModerationResponseToScript(CNetMessage* message);
+
+	/**
 	 * Call when the client has paused or unpaused the game.
 	 */
 	void SendPausedMessage(bool pause);
@@ -283,6 +313,7 @@
 	static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
 	static bool OnRejoined(void* context, CFsmEvent* event);
 	static bool OnKicked(void* context, CFsmEvent* event);
+	static bool OnModeration(void* context, CFsmEvent* event);
 	static bool OnClientTimeout(void* context, CFsmEvent* event);
 	static bool OnClientPerformance(void* context, CFsmEvent* event);
 	static bool OnClientsLoading(void* context, CFsmEvent* event);
Index: source/network/NetClient.cpp
===================================================================
--- source/network/NetClient.cpp
+++ source/network/NetClient.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -113,6 +113,7 @@
 	AddTransition(NCS_PREGAME, (uint)NMT_GAME_SETUP, NCS_PREGAME, (void*)&OnGameSetup, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_PREGAME, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_KICKED, NCS_PREGAME, (void*)&OnKicked, context);
+	AddTransition(NCS_PREGAME, (uint)NMT_MODERATION, NCS_PREGAME, (void*)&OnModeration, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_PREGAME, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_PREGAME, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_PREGAME, (uint)NMT_GAME_START, NCS_LOADING, (void*)&OnGameStart, context);
@@ -122,6 +123,7 @@
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_SETUP, NCS_JOIN_SYNCING, (void*)&OnGameSetup, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_JOIN_SYNCING, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_KICKED, NCS_JOIN_SYNCING, (void*)&OnKicked, context);
+	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_MODERATION, NCS_JOIN_SYNCING, (void*)&OnModeration, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CLIENT_TIMEOUT, NCS_JOIN_SYNCING, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CLIENT_PERFORMANCE, NCS_JOIN_SYNCING, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_START, NCS_JOIN_SYNCING, (void*)&OnGameStart, context);
@@ -133,6 +135,7 @@
 	AddTransition(NCS_LOADING, (uint)NMT_GAME_SETUP, NCS_LOADING, (void*)&OnGameSetup, context);
 	AddTransition(NCS_LOADING, (uint)NMT_PLAYER_ASSIGNMENT, NCS_LOADING, (void*)&OnPlayerAssignment, context);
 	AddTransition(NCS_LOADING, (uint)NMT_KICKED, NCS_LOADING, (void*)&OnKicked, context);
+	AddTransition(NCS_LOADING, (uint)NMT_MODERATION, NCS_LOADING, (void*)&OnModeration, context);
 	AddTransition(NCS_LOADING, (uint)NMT_CLIENT_TIMEOUT, NCS_LOADING, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_LOADING, (uint)NMT_CLIENT_PERFORMANCE, NCS_LOADING, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_LOADING, (uint)NMT_CLIENTS_LOADING, NCS_LOADING, (void*)&OnClientsLoading, context);
@@ -140,6 +143,7 @@
 
 	AddTransition(NCS_INGAME, (uint)NMT_REJOINED, NCS_INGAME, (void*)&OnRejoined, context);
 	AddTransition(NCS_INGAME, (uint)NMT_KICKED, NCS_INGAME, (void*)&OnKicked, context);
+	AddTransition(NCS_INGAME, (uint)NMT_MODERATION, NCS_INGAME, (void*)&OnModeration, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_TIMEOUT, NCS_INGAME, (void*)&OnClientTimeout, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_PERFORMANCE, NCS_INGAME, (void*)&OnClientPerformance, context);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENTS_LOADING, NCS_INGAME, (void*)&OnClientsLoading, context);
@@ -535,6 +539,64 @@
 	SendMessage(&kickPlayer);
 }
 
+void CNetClient::SendModerationMessage(CNetMessage *message)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+
+	u8 action = moderationMessage->m_Action;
+
+	if (action == NSMA_LIST_BAN || action == NSMA_LIST_MUTE || action == NSMA_LIST_HELPER)
+	{
+		// Add filler data for resistance against network request amplification
+		// Increase the length until it's within 20 bytes of the max network usage
+		while (moderationMessage->GetSerializedLength() < MODERATION_MAX_NETWORK_USAGE - 20)
+			// This should add 19 bytes
+			AddIdentifierToModerationMessage(moderationMessage, NSMIT_UNUSED, L"_filler_");
+	}
+
+	SendMessage(moderationMessage);
+}
+
+void CNetClient::AddFieldsToModerationMessage(CNetMessage* message, const u8 action, const u8 actionIsCommand,
+    const u8 responseType, const u8 responseCode, const u8 effectType)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	moderationMessage->m_Action = action;
+	moderationMessage->m_ActionIsCommand = actionIsCommand;
+	moderationMessage->m_ResponseType = responseType;
+	moderationMessage->m_ResponseCode = responseCode;
+	moderationMessage->m_EffectType = effectType;
+}
+
+void CNetClient::AddIdentifierToModerationMessage(CNetMessage* message, u8 identifierType, const CStrW& identifier)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	// Note that this is not idempotent. It will add more and more identifiers
+	// unless the identifier list is cleared at some point.
+	CModerationMessage::S_m_Identifiers identifierPair;
+	identifierPair.m_IdentifierType = identifierType;
+	identifierPair.m_Identifier = identifier;
+	moderationMessage->m_Identifiers.push_back(identifierPair);
+}
+
+void CNetClient::ResetModerationMessage(CNetMessage* message)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	moderationMessage->m_Action = NSMA_MUTE;
+	moderationMessage->m_ActionIsCommand = 0;  /* false */
+	moderationMessage->m_ResponseType = NSMRT_SILENT;
+	moderationMessage->m_ResponseCode = NSMRC_FAILED;
+	moderationMessage->m_Identifiers.erase(moderationMessage->m_Identifiers.begin(),
+	    moderationMessage->m_Identifiers.end());
+}
+
 void CNetClient::SendPausedMessage(bool pause)
 {
 	CClientPausedMessage pausedMessage;
@@ -884,6 +946,68 @@
 	return true;
 }
 
+bool CNetClient::OnModeration(void* context, CFsmEvent* event)
+{
+	ENSURE(event->GetType() == (uint)NMT_MODERATION);
+
+	CNetClient* client = static_cast<CNetClient*>(context);
+
+	CModerationMessage* moderationMessage = (CModerationMessage*)event->GetParamRef();
+
+	if(moderationMessage->m_ActionIsCommand != 1 /* true */ &&
+	    moderationMessage->m_ResponseCode != NSMRC_UNUSED)
+	{
+		client->PostModerationResponseToScript(moderationMessage);
+	}
+	return true;
+}
+
+void CNetClient::PostModerationResponseToScript(CNetMessage* message)
+{
+	ENSURE(message->GetType() == (uint)NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = (CModerationMessage*)message;
+
+	// With the data in the message, Build a JavaScript hash object that mimics an array
+
+	ScriptRequest rq(GetScriptInterface());
+
+	JS::RootedValue newModerationIdentifiers(rq.cx);
+
+	// Create a new empty plain object in the JavaScript realm
+	ENSURE(Script::CreateObject(rq, &newModerationIdentifiers));
+
+	size_t i = 0;
+	for (CModerationMessage::S_m_Identifiers& identifierPair : moderationMessage->m_Identifiers)
+	{
+		if(identifierPair.m_IdentifierType != NSMIT_UNUSED && identifierPair.m_Identifier.length() > 0)
+		{
+			JS::RootedValue identifierPairForJS(rq.cx);
+
+			ENSURE(Script::CreateObject(
+				rq,
+				&identifierPairForJS,
+				"identifierType", identifierPair.m_IdentifierType,
+				"identifier", identifierPair.m_Identifier));
+
+			// Assign a string index for each element
+			Script::SetProperty(rq, newModerationIdentifiers, CStr::FromUInt(i).c_str(), identifierPairForJS);
+			++i;
+			if (i >= MODERATION_MAX_LIST_ENTRIES)
+				break;
+		}
+	}
+	PushGuiMessage(
+		"type", "moderation-response",
+		"action", moderationMessage->m_Action,
+		"actionIsCommand", moderationMessage->m_ActionIsCommand,
+		"responseType", moderationMessage->m_ResponseType,
+		"responseCode", moderationMessage->m_ResponseCode,
+		"effectType", moderationMessage->m_EffectType,
+		"identifiers", newModerationIdentifiers);
+	return;
+}
+
 bool CNetClient::OnClientTimeout(void *context, CFsmEvent* event)
 {
 	// Report the timeout of some other client
Index: source/network/NetMessage.cpp
===================================================================
--- source/network/NetMessage.cpp
+++ source/network/NetMessage.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2017 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -215,6 +215,10 @@
 		pNewMessage = new CAssignPlayerMessage;
 		break;
 
+	case NMT_MODERATION:
+		pNewMessage = new CModerationMessage;
+		break;
+
 	default:
 		LOGERROR("CNetMessageFactory::CreateMessage(): Unknown message type '%d' received", header.GetType());
 		break;
Index: source/network/NetMessages.h
===================================================================
--- source/network/NetMessages.h
+++ source/network/NetMessages.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2021 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -28,7 +28,7 @@
 
 #define PS_PROTOCOL_MAGIC                         0x5073013f	// 'P', 's', 0x01, '?'
 #define PS_PROTOCOL_MAGIC_RESPONSE                0x50630121	// 'P', 'c', 0x01, '!'
-#define PS_PROTOCOL_VERSION                       0x01010018	// Arbitrary protocol
+#define PS_PROTOCOL_VERSION                       0x01010019	// Arbitrary protocol
 #define PS_DEFAULT_PORT                           0x5073		// 'P', 's'
 
 // Set when lobby authentication is required. Used in the SrvHandshakeResponseMessage.
@@ -80,7 +80,9 @@
 	NMT_SYNC_CHECK,	// OOS-detection hash checking
 	NMT_SYNC_ERROR,	// OOS-detection error
 
-	NMT_SIMULATION_COMMAND
+	NMT_SIMULATION_COMMAND,
+
+	NMT_MODERATION
 };
 
 // Authentication result codes
@@ -240,6 +242,19 @@
 	NMT_FIELD(CStr, m_GUID)
 END_NMT_CLASS()
 
+START_NMT_CLASS_(Moderation, NMT_MODERATION)
+	NMT_FIELD_INT(m_Action, u8, 1)
+	NMT_FIELD_INT(m_ActionIsCommand, u8, 1)
+	NMT_FIELD_INT(m_ResponseType, u8, 1)
+	NMT_FIELD_INT(m_ResponseCode, u8, 1)
+	NMT_FIELD_INT(m_EffectType, u8, 1)
+	NMT_START_ARRAY(m_Identifiers)
+		NMT_FIELD_INT(m_IdentifierType, u8, 1)
+		NMT_FIELD(CStrW, m_Identifier)
+	NMT_END_ARRAY()
+END_NMT_CLASS()
+
+
 END_NMTS()
 
 #else
Index: source/network/NetModerationTables.h
===================================================================
--- source/network/NetModerationTables.h
+++ source/network/NetModerationTables.h
@@ -0,0 +1,106 @@
+/* Copyright (C) 2023 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NETMODERATIONTABLES_H
+#define NETMODERATIONTABLES_H
+
+enum ModerationAction
+{
+	NSMA_KICK = 1,
+	NSMA_BAN,
+	NSMA_KICK_BAN,
+	NSMA_MUTE,
+	NSMA_HELPER,
+	NSMA_UNBAN,
+	NSMA_UNMUTE,
+	NSMA_UNHELPER,
+	NSMA_LIST_BAN,
+	NSMA_LIST_MUTE,
+	NSMA_LIST_HELPER
+};
+
+enum ModerationResponseType
+{
+	// No responses, except admin notification of actions by helpers
+	NSMRT_SILENT = 0,
+	// Admin notification of actions by helpers, and error messages
+	NSMRT_INFO,
+	// Broadcast announcements of successful effects of commands except list requests
+	NSMRT_ANNOUNCEMENT
+};
+
+enum ModerationResponseCode
+{
+	NSMRC_UNUSED = 0,
+	NSMRC_FAILED,
+	NSMRC_SUCCESS,
+	NSMRC_PERMISSION_DENIED,
+	NSMRC_IDENTIFIER_NOT_ON_SERVER,
+	NSMRC_IDENTIFIER_NOT_IN_LIST,
+	NSMRC_IDENTIFIER_ALREADY_IN_LIST,
+	NSMRC_CANNOT_RESTRICT_HOST,
+	NSMRC_SYNTAX_ERROR,
+	NSMRC_CAPACITY_EXCEEDED,
+	NSMRC_INSUFFICIENT_FILLER_DATA,
+	NSMRC_LIST
+};
+
+enum ModerationEffectType
+{
+	NSMET_IP = 1,
+	NSMET_USERNAME,
+	NSMET_USERNAME_AND_IP
+};
+
+enum ModerationIdentifierType
+{
+	NSMIT_UNUSED = 0,
+	NSMIT_IP,
+	NSMIT_USERNAME_PRESENT,
+	NSMIT_USERNAME_NOT_PRESENT,
+	NSMIT_USERNAME_IN_LIST_REGEX,
+	NSMIT_USERNAME_COMMAND_ISSUER,
+	NSMIT_GUID
+};
+
+/**
+ * Max number of elements in a moderation list. If this needs to be
+ * adjusted then ensure that the types used elsewhere are compatible,
+ * e.g. iterators and transfer of identifiers to JavaScript realm
+ * (CNetClient::OnModeration())
+ **/
+constexpr u8 MODERATION_MAX_LIST_ENTRIES{254};
+
+/**
+ * Max size in bytes of memory usage of a moderation list. Note that
+ * 32KB easily supports 254 names of average length 15 characters. If
+ * this needs to be adjusted then keep it less than SIZE_MAX on the
+ * targeted architecture(s), and consider performance effects
+ **/
+constexpr u32 MODERATION_MAX_LIST_MEMORY_USAGE{32767UL};
+
+/**
+ * Max size in bytes of network usage of a moderation response.
+ * The current values avoid sending fragmented packets
+ * Default ethernet MTU: 1500 bytes
+ * TCP/IP and ethernet overhead: 42 bytes
+ * Headroom for tunneled network protocols, VPN, IPSec, etc.: 100 bytes
+ * 1500 - 100 - 42 = 1358
+ **/
+constexpr u32 MODERATION_MAX_NETWORK_USAGE{1358};
+
+#endif
Index: source/network/NetServer.h
===================================================================
--- source/network/NetServer.h
+++ source/network/NetServer.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -20,6 +20,8 @@
 
 #include "NetFileTransfer.h"
 #include "NetHost.h"
+#include "NetModerationTables.h"
+#include "NetMessage.h"
 #include "lib/config2.h"
 #include "lib/types.h"
 #include "scriptinterface/ScriptTypes.h"
@@ -169,17 +171,24 @@
 	u16 GetLocalPort() const;
 
 	/**
-	 * Check if password is valid. If is not, increase number of failed attempts of the lobby user.
-	 * This is used without established direct session with the client, to prevent brute force attacks
-	 * when guessing password trying to get connection data from the host.
+	 * Check if password is valid. If not, increase number of failed
+	 * attempts of the lobby user. This function is used by XmppClient to
+	 * check the password sent by the lobby user that's requesting a
+	 * connection. This occurs before a direct session is established with
+	 * the client. Clients with too many failed password attempts are
+	 * added to the server's ban list by name. The purpose is to prevent
+	 * brute force attacks
 	 * @return true iff password is valid
 	 */
 	bool CheckPasswordAndIncrement(const std::string& username, const std::string& password, const std::string& salt);
 
 	/**
-	 * Check if user reached certain number of failed attempts.
+	 * Check if user is banned from the server.
+	 * This function is used by XmppClient to check whether the username
+	 * is banned. If so then the server's public IP address is not sent to
+	 * the lobby user
 	 * @see m_BanAfterNumberOfTries
-	 * @see CheckPasswordAndBan
+	 * @see CheckPasswordAndIncrement
 	 */
 	bool IsBanned(const std::string& username) const;
 
@@ -221,12 +230,154 @@
 	 */
 	bool SendMessage(ENetPeer* peer, const CNetMessage* message);
 
+	/* Begin public moderation functions */
+
 	/**
-	 * Disconnects a player from gamesetup or session.
+	 * Disconnect a player from gamesetup or session.
+	 * This is provided for backwards compatibility with CKickedMessage
 	 */
 	void KickPlayer(const CStrW& playerName, const bool ban);
 
 	/**
+	 * Disconnect a player from gamesetup or session.
+	 * @param interactive if true then send moderation response info messages on errors
+	 * @return true if the user was found and kicked successfully
+	 */
+	bool KickUser(const CStrW& username, const bool interactiveRequested);
+
+	/**
+	 * Front-end function to moderate (kick, ban, mute, or add to helpers
+	 * list) or un-moderate a player or IP from gamesetup or session.
+	 * Enforces permissions for use of moderation commands, although the
+	 * caller is expected to determine the level of permission that the
+	 * command issuing user should have.
+	 * @param context a pointer to the CNetServerSession object that the
+	 *                message is associated with.
+	 * @param inputMessageSize the serialized length of the command message that
+	 *                         requested this call to Moderation. This only affects
+	 *                         list output, and is intended to prevent network request
+	 *                         amplification. If this call was generated by the
+	 *                         engine itself instead of a user request (for example
+	 *                         when a user is banned after too many failed password
+	 *                         attempts) then pass 0 for this parameter.
+	 * @param userPrivilegeLevel true if the command issuer is the controller or host of
+	 *                           the game. False if the command issuer is a moderation
+	 *                           helper, with access only to the mute list commands
+	 * @param action a value in the NetServerModerationAction enum indicating the
+	 *               command that was issued, for example kick, ban, mute, etc.
+	 * @param responseType a value in the NetServerModerationResponseType enum
+	 *                     indicating the type of moderation response to provide.
+	 *                     For example an announcement would cause a broadcasted
+	 *                     announcement of a successful result
+	 * @param effectType a value in the NetServerModerationEffectType enum
+	 *                   indicating whether to add the user's name, IP address, or
+	 *                   both to the moderation list
+	 * @param identifiers a vector of pairs of {identifier and identifierType},
+	 *                    where an identifier is a username or IP address,
+	 *                    depending on identifierType
+	 */
+	void Moderation(void* context, const size_t inputMessageSize, const bool userPrivilegeLevel,
+	    const u8 action, const u8 responseType, const u8 effectType,
+            const std::vector<CModerationMessage::S_m_Identifiers>& identifiers);
+
+	/**
+	 * Add or remove a username or IP address to a moderation list. Note that
+	 * this function assumes that permission checks were done earlier wrt the
+	 * action, effect type, and the privilege level of the user that issued the
+	 * command.
+	 * @param interactive if true, send moderation responses to the user that
+	 *                    sent the moderation request message. Also, if responseType
+	 *                    is announcement then send a broadcast message to all users
+	 *                    when a user is added to or removed from a moderation list.
+	 * @param addOrRemove if true, add the identifier to the list. If false,
+	 *                    remove it.
+	 * @param listIsRestrictive if true, the list causes a restriction on users in
+	 *                          the list. If false, the list may cause an elevated
+	 *                          privilege of users in the list.
+	 * @param listUsernames the list of usernames that the user should
+	 *                      be added to, if requested by effectType
+	 *                      username. Example: m_BannedUsers
+	 * @param listIPs the list of IP addresses that the user should be
+	 *                added to, if requested by effectType ip. Example:
+	 *                m_BannedIPs
+	 * @return true if the intended effect has been or already was accomplished,
+	 *         false if there was a syntax error or invalid command specified.
+	 */
+	bool UpdateModerationList(void* context, const bool interactiveRequested, const bool userPrivilegeLevel,
+	    const u8 action, u8 responseType, const u8 effectType,
+	    const std::vector<CModerationMessage::S_m_Identifiers>& identifiers,
+	    const bool addOrRemove, const bool listIsRestrictive,
+	    std::vector<CStrW>& listUsernames, std::vector<u32>& listIPs);
+
+	/**
+	 * Back-end function to Send moderation response messages to the host
+	 * controller client with a list of banned, muted, or helper users
+	 */
+	void OutputModerationList(void* context, const size_t inputMessageSize,
+	    const bool interactiveRequested, const bool userPrivilegeLevel,
+	    const u8 action, u8 responseType, const u8 effectType,
+	    const std::vector<CStrW>& listUsernames,
+	    const std::vector<u32>& listIPs);
+
+	/**
+	 * Fill a CModerationMessage with the field data in the arguments.
+	 * Does not affect the identifiers in the message
+	 */
+	static void AddFieldsToModerationMessage(CNetMessage* message, const u8 action, const u8 actionIsCommand,
+	    const u8 responseType, const u8 responseCode, const u8 effectType);
+
+	/**
+	 * Add a single identifier to the end of the list of identifiers in
+	 * a CModerationMessage.
+	 */
+	static void AddIdentifierToModerationMessage(CNetMessage* message, const u8 identifierType, const CStrW& identifier);
+
+	/**
+	 * Lookup the IP addresses used by the host and controller client and
+	 * compare them with the integer-encoded IP address in the argument
+	 */
+	// bool CompareIPWithHostAndControllerIPs(const u32 ipAddress);
+
+	/**
+	 * Search through the list of sessions (network connections with
+	 * clients) and find the session of the client that is the controller
+	 * of the server
+	 */
+	CNetServerSession* GetControllerSession();
+
+	/**
+	 * Search through the list of usernames and return true if the username is found
+	 */
+	static bool IsIPInList(const u32 ipAddress, const std::vector<u32>& list);
+	/**
+	 * Search through the list of usernames and return true if the username is found
+	 */
+	static bool IsSimpleUsernameInList(const CStrW& username, const std::vector<CStrW>& list,
+	    const bool lobbyAuth);
+
+	/**
+	 * Fills a CModerationMessage with the default field data and empty
+	 * identifiers list
+	 */
+	static void ResetModerationMessage(CNetMessage* message);
+
+	/**
+	 * Given a vector of identifiers, extract the first username and IP
+	 * address from the vector ofidentifiers
+	 * @return tuple of username, usernameIdentifierType, ip
+	 */
+	static std::tuple<CStrW, u8, CStrW> RetrieveFirstUsernameAndIPFromIdentifiers(
+	    const std::vector<CModerationMessage::S_m_Identifiers>& identifiers);
+
+	/**
+	 * Remove the rating and converts to lowercase a username
+	 */
+	static CStrW SimpleUsername(const CStrW& username, const bool lobbyAuth);
+
+
+	/* End public moderation functions */
+
+	/**
 	 * Send a message to all clients who match one of the given states.
 	 */
 	bool Broadcast(const CNetMessage* message, const std::vector<NetServerSessionState>& targetStates);
@@ -292,6 +443,183 @@
 	void SetupSession(CNetServerSession* session);
 	bool HandleConnect(CNetServerSession* session);
 
+	/* Begin private moderation functions */
+
+	/**
+	 * Add the contents of a moderation list of IPs to a
+	 * CModerationMessage, as identifiers. The IPs are converted to
+	 * strings prior to being added to the message as identifiers with
+	 * identifierType IP
+	 * @param message a pointer to the CModerationMessage object to which
+	 *                the list contents should be added as identifiers
+	 */
+	static void AddIPListToModerationMessage(CNetMessage* message, const std::vector<u32>& listIPs);
+
+	/**
+	 * Directly add an IP address to the specified list of IPs. Note: the
+	 * caller is expected to check whether additions to the list would be
+	 * within the max moderation list memory limit.
+	 * See IsSizeOfUsernameListsWithinMemoryLimit().
+	 * @param ipAddress an integer in enet or inet.h (addr.host) format
+	 *                  that represents an IP address
+	 * @param list the moderation list to which the identifier should be added
+	 * @return true if the addition was done,
+	 *         false if the memory or element count limits would be exceeded
+	 */
+	static bool AddIPToList(u32 ipAddress, std::vector<u32>& list);
+
+	/**
+	 * Add the contents of a string-based moderation list, for example
+	 * Usernames, to a CModerationMessage, as identifiers with
+	 * identifierType NAME_NOT_PRESENT
+	 * @param message a pointer to the CModerationMessage object to which
+	 *                the list contents should be added as identifiers
+	 */
+	static void AddUsernameListToModerationMessage(CNetMessage* message, const std::vector<CStrW>& listUsernames);
+
+	/**
+	 * Directly add a username or other string-based identifier to the
+	 * specified list of identifiers. Note: the caller is expected to check
+	 * whether additions to the list would be within the max moderation
+	 * list memory limit. See IsSizeOfUsernameListsWithinMemoryLimit().
+	 * @param identifier a string that represents a username or other
+	 *                   string-based identifier
+	 * @param list the moderation list to which the identifier should be added
+	 * @return true if the addition was done, false if the memory or
+	 *         element count limits would be exceeded
+	 */
+	static bool AddUsernameToList(const CStrW& identifier, std::vector<CStrW>& list);
+
+
+	/**
+	 * Determine whether the combined sizes in number of elements and
+	 * bytes of data are less than the provided limits. This is a generic
+	 * function that merely takes counts and sizes as input and checks
+	 * whether they are less than the limit in a way that avoids integer
+	 * overflow
+	 * @return true if the combined size of the identifiers is within the limit
+	 */
+	static bool IsSizeOfDataWithinLimits(const size_t numEntriesList1, const size_t size1, const size_t numEntriesList2,
+	    const size_t size2, const size_t entryLimit, const size_t sizeLimit);
+
+	/**
+	 * Determine whether the combined size of the Username, IP and command
+	 * issuer are less than the maximum (arbitrary) limits for network
+	 * packet size and number of elements
+	 * @return true if the combined size of the identifiers is within the
+	 *         limit
+	 */
+	static bool IsSizeOfIdentifiersWithinNetworkLimit(const bool useUsername, const bool useIP, const bool useCommandIssuer,
+	    const CStrW& username, const CStrW& ipAddressString, const CStrW& commandIssuer);
+
+	/**
+	 * Determine whether the combined size of the Username and IP lists
+	 * are less than the maximum (arbitrary) limits for network packet
+	 * size and number of elements
+	 * @return true if the combined size of the lists is within the limit
+	 */
+	static bool IsSizeOfModerationListsWithinNetworkLimit(const bool useUsernames, const bool useIPs,
+	    const std::vector<CStrW>& listUsernames, const std::vector<u32>& listIPs);
+
+	/**
+	 * Determine whether the combined size of the Username lists is less
+	 * than the maximum (arbitrary) limits for memory usage and number of
+	 * elements
+	 * @return true if the size is within the limit
+	 */
+	static bool IsSizeOfUsernameListsWithinMemoryLimit(const std::vector<CStrW>& listUsernames1,
+	    const std::vector<CStrW>& listUsernames2);
+
+	/**
+	 * Determine whether the combined size of the IP lists is less than
+	 * the maximum (arbitrary) limit for memory usage and number of elements
+	 * @return true if the size is within the limit
+	 */
+	static bool IsSizeOfIPListsWithinMemoryLimit(const std::vector<u32>& listIPs1, const std::vector<u32>& listIPs2);
+
+	/**
+	 * Send moderation response messages informing clients that a
+	 * moderation command was processed successfully
+	 * Arguments are similar to those in Moderation()
+	 */
+	void ReportModerationResults(void* context, const bool interactive, const bool userPrivilegeLevel,
+	    const u8 action, const u8 responseType, const u8 responseCode,
+	    const u8 effectType, const bool useUsername, const bool useIP,
+	    const bool useGUID, const u8 usernameIdentifierType, const CStrW& username,
+	    const CStrW& ipAddressString, const CStrW& GUID, const CStrW& commandIssuer);
+
+	/**
+	 * Compute the size of the IP list
+	 * @param IPListOverhead the number of bytes used by the list data
+	 *                       even when there are 0 elements in the list
+	 * @param IPLengthFactor the number of bytes used by each character of
+	 *                       each list element
+	 * @param IPOverhead the number of bytes used by each list element,
+	 *                   even when there are 0 characters in the list element
+	 * @param listIPs the list of IPs of which to calculate the size.
+	 *                Example: m_MutedIPs
+	 * @return the combined size of the lists. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfIPList(const unsigned int IPListOverhead, const unsigned int IPLengthFactor,
+	    const unsigned int IPOverhead, const std::vector<u32>& listIPs);
+
+	/**
+	 * Calculate the size of the username list
+	 * @param usernameListOverhead the number of bytes used by the list
+	 *                             data even when there are 0 elements in the list
+	 * @param usernameLengthFactor the number of bytes used by each
+	 *                             character of each list element
+	 * @param usernameOverhead the number of bytes used by each list
+	 *                         element, even when there are 0 characters in the list element
+	 * @param listUsernames the list of usernames of which to calculate
+	 *                      the size. Example: m_MutedUsers
+	 * @return the combined size of the lists. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfUsernameList(const unsigned int usernameListOverhead,
+	    const unsigned int usernameLengthFactor, const unsigned int usernameOverhead,
+	    const std::vector<CStrW>& listUsernames);
+
+	/**
+	 * Calculate the size of the IP list as it would be stored in memory
+	 * @return size of the list in bytes. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfIPListInMemory(const std::vector<u32>& listIPs);
+
+	/**
+	 * Calculate the size of the Username list as it would be stored in memory
+	 * @return size of the list in bytes. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfUsernameListInMemory(const std::vector<CStrW>& listUsernames);
+
+	/**
+	 * Calculate the size of the IP list as it would be sent over the network
+	 * @return size of the IP list in bytes. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfIPListInNetwork(const std::vector<u32>& listIPs);
+
+	/**
+	 * Calculate the size of the Username list as it would be sent over the network
+	 * @return size of the IP list in bytes. On overflow, return SIZE_MAX.
+	 */
+	static size_t SizeOfUsernameListInNetwork(const std::vector<CStrW>& listUsernames);
+
+	/**
+	 * Directly remove an IP address from the specified list of IPs
+	 * @return true if the removal was successful,
+	 *         false if the element was not in the list.
+	 */
+	static bool RemoveIPFromList(u32 ipAddress, std::vector<u32>& list);
+
+	/**
+	 * Directly remove a username from the specified list of usernames
+	 * @return true if the removal was successful,
+	 *         false if the element was not in the list.
+	 */
+	static bool RemoveUsernameFromList(const CStrW& identifier,
+	    std::vector<CStrW>& list);
+
+	/* End private moderation functions */
+
 	void OnUserJoin(CNetServerSession* session);
 	void OnUserLeave(CNetServerSession* session);
 
@@ -310,6 +638,7 @@
 	static bool OnJoinSyncingLoadedGame(void* context, CFsmEvent* event);
 	static bool OnRejoined(void* context, CFsmEvent* event);
 	static bool OnKickPlayer(void* context, CFsmEvent* event);
+	static bool OnModeration(void* context, CFsmEvent* event);
 	static bool OnDisconnect(void* context, CFsmEvent* event);
 	static bool OnClientPaused(void* context, CFsmEvent* event);
 
@@ -364,7 +693,14 @@
 	CStrW m_ServerName;
 
 	std::vector<u32> m_BannedIPs;
-	std::vector<CStrW> m_BannedPlayers;
+	std::vector<CStrW> m_BannedUsers;
+
+	std::vector<u32> m_MutedIPs;
+	std::vector<CStrW> m_MutedUsers;
+
+	std::vector<u32> m_HelperIPs;
+	std::vector<CStrW> m_HelperUsers;
+
 
 	CStr m_Password;
 
Index: source/network/NetServer.cpp
===================================================================
--- source/network/NetServer.cpp
+++ source/network/NetServer.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -48,6 +48,9 @@
 #endif
 
 #include <string>
+#include <vector>     /* For std::vector */
+#include <tuple>      /* For std::tuple and std::tie */
+#include <algorithm>  /* For std::any_of */
 
 /**
  * Number of peers to allocate for the enet host.
@@ -143,6 +146,8 @@
 /*
  * XXX: We use some non-threadsafe functions from the worker thread.
  * See http://trac.wildfiregames.com/ticket/654
+ * Update: the ticket is closed, as it is mostly fixed. "debug_filter stuff
+ * remains non-reentrant."
  */
 
 CNetServerWorker::CNetServerWorker(bool useLobbyAuth) :
@@ -157,6 +162,13 @@
 	m_ServerTurnManager = NULL;
 
 	m_ServerName = DEFAULT_SERVER_NAME;
+
+	m_BannedUsers.reserve(MODERATION_MAX_LIST_ENTRIES);
+	m_BannedIPs.reserve(MODERATION_MAX_LIST_ENTRIES);
+	m_MutedUsers.reserve(MODERATION_MAX_LIST_ENTRIES);
+	m_MutedIPs.reserve(MODERATION_MAX_LIST_ENTRIES);
+	m_HelperUsers.reserve(MODERATION_MAX_LIST_ENTRIES);
+	m_HelperIPs.reserve(MODERATION_MAX_LIST_ENTRIES);
 }
 
 CNetServerWorker::~CNetServerWorker()
@@ -330,7 +342,8 @@
 		debug_warn(L"Unrecognized return value from UPNP_GetValidIGD");
 	}
 
-	// Try getting our external/internet facing IP. TODO: Display this on the game-setup page for conviniance.
+	// Try getting our external/internet facing IP.
+	// TODO: Display this on the game-setup page for convenience.
 	ret = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
 	if (ret != UPNPCOMMAND_SUCCESS)
 	{
@@ -697,15 +710,18 @@
 	session->AddTransition(NSS_PREGAME, (uint)NMT_GAME_SETUP, NSS_PREGAME, (void*)&OnGameSetup, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_ASSIGN_PLAYER, NSS_PREGAME, (void*)&OnAssignPlayer, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_KICKED, NSS_PREGAME, (void*)&OnKickPlayer, context);
+	session->AddTransition(NSS_PREGAME, (uint)NMT_MODERATION, NSS_PREGAME, (void*)&OnModeration, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_GAME_START, NSS_PREGAME, (void*)&OnGameStart, context);
 	session->AddTransition(NSS_PREGAME, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnLoadedGame, context);
 
 	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_KICKED, NSS_JOIN_SYNCING, (void*)&OnKickPlayer, context);
+	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_MODERATION, NSS_JOIN_SYNCING, (void*)&OnModeration, context);
 	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
 	session->AddTransition(NSS_JOIN_SYNCING, (uint)NMT_LOADED_GAME, NSS_INGAME, (void*)&OnJoinSyncingLoadedGame, context);
 
 	session->AddTransition(NSS_INGAME, (uint)NMT_REJOINED, NSS_INGAME, (void*)&OnRejoined, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_KICKED, NSS_INGAME, (void*)&OnKickPlayer, context);
+	session->AddTransition(NSS_INGAME, (uint)NMT_MODERATION, NSS_INGAME, (void*)&OnModeration, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_CLIENT_PAUSED, NSS_INGAME, (void*)&OnClientPaused, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_CONNECTION_LOST, NSS_UNCONNECTED, (void*)&OnDisconnect, context);
 	session->AddTransition(NSS_INGAME, (uint)NMT_CHAT, NSS_INGAME, (void*)&OnChat, context);
@@ -824,38 +840,1288 @@
 	SendPlayerAssignments();
 }
 
-void CNetServerWorker::KickPlayer(const CStrW& playerName, const bool ban)
+/* Begin public moderation functions */
+
+void CNetServerWorker::KickPlayer(const CStrW& username, bool ban)
 {
-	// Find the user with that name
+	CNetServerSession* context = GetControllerSession();
+
+	if (context)
+	{
+		const u8 action = ban ? NSMA_KICK_BAN : NSMA_KICK;
+		std::vector<CModerationMessage::S_m_Identifiers> identifiers;
+		CModerationMessage::S_m_Identifiers identifierPair;
+		identifierPair.m_IdentifierType = NSMIT_USERNAME_PRESENT;
+		identifierPair.m_Identifier = username;
+		identifiers.push_back(identifierPair);
+		Moderation(context, 0, true, action, NSMRT_ANNOUNCEMENT, NSMET_USERNAME, identifiers);
+	}
+}
+
+bool CNetServerWorker::KickUser(const CStrW& username, const bool interactiveRequested)
+{
+	CNetServerSession* session = GetControllerSession();
+
+	CModerationMessage moderationInfoFailed;
+	AddFieldsToModerationMessage(&moderationInfoFailed, NSMA_KICK, false,
+	    NSMRT_INFO, NSMRC_FAILED, NSMET_USERNAME);
+
+	const bool interactive{session != NULL && interactiveRequested};
+
+	if (username.empty())
+	{
+		if (interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return false;
+	}
+	// Find user session
+	const CStrW usernameToFind = SimpleUsername(username, m_LobbyAuth);
 	std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
-		[&](CNetServerSession* session) { return session->GetUserName() == playerName; });
+		[&](CNetServerSession* theSession)
+		{
+			return SimpleUsername(theSession->GetUserName(), m_LobbyAuth) == usernameToFind;
+		});
+	if (it == m_Sessions.end())
+	{
+		if (interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_IDENTIFIER_NOT_ON_SERVER;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return false;
+	}
+
+	if ((*it)->GetGUID() == m_ControllerGUID)
+	{
+		if (interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_CANNOT_RESTRICT_HOST;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return false;
+	}
+
+	// Checks passed. Disconnect the user
+	(*it)->Disconnect(NDR_KICKED);
+	return true;
+	// Caller is expected to report the results
+}
+
+void CNetServerWorker::Moderation(void* context, const size_t inputMessageSize, const bool userPrivilegeLevel,
+    const u8 action, const u8 responseType, const u8 effectType,
+    const std::vector<CModerationMessage::S_m_Identifiers>& identifiers)
+{
+	if (responseType != NSMRT_ANNOUNCEMENT && responseType != NSMRT_INFO && responseType != NSMRT_SILENT)
+	{
+		// Response type invalid. Silently drop the request.
+		LOGWARNING("CNetServerWorker::Moderation: Invalid moderation response type. Dropping request.");
+		return;
+	}
+
+	CNetServerSession *session = (CNetServerSession *)context;
+	const bool interactive{session != NULL && responseType != NSMRT_SILENT};
+
+	CModerationMessage moderationResponseSyntaxError;
+	AddFieldsToModerationMessage(&moderationResponseSyntaxError, action,
+	    false, NSMRT_INFO, NSMRC_SYNTAX_ERROR, effectType);
+
+	CModerationMessage moderationInfoFailed(moderationResponseSyntaxError);
+	moderationInfoFailed.m_ResponseCode = NSMRC_FAILED;
+
+	CModerationMessage moderationInfoSuccess(moderationResponseSyntaxError);
+	moderationInfoSuccess.m_ResponseCode = NSMRC_SUCCESS;
+
+	CStrW username;
+	u8 usernameIdentifierType;
+	CStrW ip;
+	std::tie(username, usernameIdentifierType, ip) = RetrieveFirstUsernameAndIPFromIdentifiers(identifiers);
+
+	// Helpers can only work with the mute list and usernames
+	if (!userPrivilegeLevel && (
+		(action != NSMA_MUTE && action != NSMA_UNMUTE && action != NSMA_LIST_MUTE) ||
+		!(ip.empty()) || effectType != NSMET_USERNAME ||
+		(action == NSMA_MUTE && !(username.empty()) && usernameIdentifierType != NSMIT_USERNAME_PRESENT)))
+	{
+		if(interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_PERMISSION_DENIED;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return;
+	}
+
+	if (effectType != NSMET_IP && effectType != NSMET_USERNAME && effectType != NSMET_USERNAME_AND_IP)
+	{
+		// Effect type invalid. Return with an error
+		if (interactive)
+		{
+			session->SendMessage(&moderationResponseSyntaxError);
+		}
+		return;
+	}
+
+	switch (action)
+	{
+	case NSMA_KICK:
+		if (!(username.empty()) && usernameIdentifierType == NSMIT_USERNAME_PRESENT &&
+		   (effectType == NSMET_USERNAME || effectType == NSMET_USERNAME_AND_IP))
+		{
+			CStrW GUIDOfUsername = L"";
+			const CStrW usernameToFind = SimpleUsername(username, m_LobbyAuth);
+			std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
+				[&](CNetServerSession* theSession)
+				{
+					return SimpleUsername(theSession->GetUserName(), m_LobbyAuth) == usernameToFind;
+				});
+			if (it != m_Sessions.end())
+			{
+				CNetServerSession* userSession = (*it);
+				GUIDOfUsername = wstring_from_utf8(userSession->GetGUID());
+				if(KickUser(username, interactive))
+				{
+					CStrW commandIssuer = session ? session->GetUserName() : L"";
+					if (commandIssuer.empty())
+						commandIssuer = L"(unknown)";
+					// Always announce kicks, regardless of requested response type. This way
+					// people don't think that kicked players disconnected voluntarily or due to
+					// technical difficulties
+					ReportModerationResults(session, true, true, NSMA_KICK, NSMRT_ANNOUNCEMENT,
+					    NSMRC_SUCCESS, NSMET_USERNAME, true, false, true,
+					    NSMIT_USERNAME_PRESENT, username, L"", GUIDOfUsername, commandIssuer);
+				}
+				// KickUser() already handles sending responses about errors
+			}
+		}
+		else
+		{
+			// Syntax error
+			if (interactive)
+			{
+				moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+				session->SendMessage(&moderationInfoFailed);
+			}
+		}
+		break;
+	case NSMA_KICK_BAN:
+		if (!(username.empty()) && usernameIdentifierType == NSMIT_USERNAME_PRESENT &&
+		   (effectType == NSMET_USERNAME || effectType == NSMET_USERNAME_AND_IP))
+		{
+			UpdateModerationList(context, interactive, userPrivilegeLevel,
+			    action, responseType, effectType, identifiers, true, true,
+			    m_BannedUsers, m_BannedIPs);
+		}
+		else
+		{
+			// Syntax error
+			if (interactive)
+			{
+				moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+				session->SendMessage(&moderationInfoFailed);
+			}
+		}
+		break;
+	case NSMA_BAN:
+		// Only add the player to the ban list
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, true, true,
+		    m_BannedUsers, m_BannedIPs);
+		break;
+	case NSMA_UNBAN:
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, false,
+		    true, m_BannedUsers, m_BannedIPs);
+		break;
+	case NSMA_MUTE:
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, true,
+		    true, m_MutedUsers, m_MutedIPs);
+		break;
+	case NSMA_UNMUTE:
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, false,
+		    true, m_MutedUsers, m_MutedIPs);
+		break;
+	case NSMA_HELPER:
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, true,
+		    false, m_HelperUsers, m_HelperIPs);
+		break;
+	case NSMA_UNHELPER:
+		UpdateModerationList(context, interactive, userPrivilegeLevel,
+		    action, responseType, effectType, identifiers, false,
+		    false, m_HelperUsers, m_HelperIPs);
+		break;
+	case NSMA_LIST_BAN:
+		OutputModerationList(context, inputMessageSize, interactive,
+		    userPrivilegeLevel, action, responseType,
+		    effectType, m_BannedUsers, m_BannedIPs);
+		break;
+	case NSMA_LIST_MUTE:
+		OutputModerationList(context, inputMessageSize, interactive,
+		    userPrivilegeLevel, action, responseType,
+		    effectType, m_MutedUsers, m_MutedIPs);
+		break;
+	case NSMA_LIST_HELPER:
+		OutputModerationList(context, inputMessageSize, interactive,
+		    userPrivilegeLevel, action, responseType,
+		    effectType, m_HelperUsers, m_HelperIPs);
+		break;
+	default:
+		// Command invalid. Return with an error
+		if (interactive)
+			session->SendMessage(&moderationResponseSyntaxError);
+		break;
+	}
+
+}
+
+bool CNetServerWorker::UpdateModerationList(void* context, const bool interactiveRequested, const bool userPrivilegeLevel, const u8 action,
+    u8 responseType, const u8 effectType,
+    const std::vector<CModerationMessage::S_m_Identifiers>& identifiers,
+    const bool addOrRemove, const bool listIsRestrictive,
+    std::vector<CStrW>& listUsernames, std::vector<u32>& listIPs)
+{
+	CNetServerSession *session;
+
+	session = (CNetServerSession *)context;
+
+	const bool interactive{session != NULL && interactiveRequested};
+
+	CStrW username;
+	u8 usernameIdentifierType;
+	CStrW ip;
+	std::tie(username, usernameIdentifierType, ip) = RetrieveFirstUsernameAndIPFromIdentifiers(identifiers);
+
+	CModerationMessage moderationInfoSuccess;
+	AddFieldsToModerationMessage(&moderationInfoSuccess, action, false,
+	    NSMRT_INFO, NSMRC_SUCCESS, effectType);
+
+	CModerationMessage moderationInfoFailed;
+	AddFieldsToModerationMessage(&moderationInfoFailed, action, false,
+	    NSMRT_INFO, NSMRC_FAILED, effectType);
+
+	// Check whether the user has permission to use an IP address
+	// identifier or effect
+	if (!userPrivilegeLevel && (!(ip.empty()) || effectType == NSMET_IP ||
+	    effectType == NSMET_USERNAME_AND_IP))
+	{
+		// Permission denied, return an error
+		if (interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_PERMISSION_DENIED;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return false;
+	}
+
+	// Check whether the commands are self-consistent
+	// In order to kick a user or have an effect on an IP given only a
+	// username, the user must be present
+	if ((!(username.empty()) && usernameIdentifierType !=
+	    NSMIT_USERNAME_PRESENT) && ((action == NSMA_KICK ||
+	    action == NSMA_KICK_BAN) || (effectType == NSMET_IP)))
+	{
+		if (interactive)
+		{
+			moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+			session->SendMessage(&moderationInfoFailed);
+		}
+		return false;
+	}
+
+	bool resultUsernameEffectOnUsername = false;
+	// Currently unused, so commented out to squash a compiler warning
+	// about unused variable
+	// bool resultUsernameEffectOnIP = false;
+	bool resultIPEffectOnIP = false;
+
+	bool usernamePresent = false;
+	u32 IPAddressOfUsername = ENET_HOST_ANY;
+	CStrW GUIDOfUsername = L"";
+	// Check whether the specified username is on the server, if the
+	// username is required to be present based on the command. Also
+	// retrieve the IP address and GUID of the user
+	if (!(username.empty()) && usernameIdentifierType == NSMIT_USERNAME_PRESENT)
+	{
+		const CStrW usernameToFind = SimpleUsername(username, m_LobbyAuth);
+		std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
+			[&](CNetServerSession* theSession)
+			{
+				return SimpleUsername(theSession->GetUserName(), m_LobbyAuth) == usernameToFind;
+			});
+
+		if (it != m_Sessions.end())
+		{
+			usernamePresent = true;
+			IPAddressOfUsername = (*it)->GetIPAddress();
+			GUIDOfUsername = wstring_from_utf8((*it)->GetGUID());
+		}
+		if (!usernamePresent)
+		{
+			// The user is required to be present, but was not found. Return with an error
+			if (interactive)
+			{
+				moderationInfoFailed.m_ResponseCode = NSMRC_IDENTIFIER_NOT_ON_SERVER;
+				session->SendMessage(&moderationInfoFailed);
+			}
+			return false;
+		}
+	}
+
+	// Ensure that the requested operations are done as a transaction (all or
+	// nothing, and atomically). First make the changes to temporary storage.
+	// If all checks are successful then commit the updates to the actual
+	// moderation lists.
+
+	std::vector<CStrW> tempListUsernames;
+	std::vector<u32> tempListIPs;
+
+	// Process the provided username for effect on username
+	if (!(username.empty()) && ((usernameIdentifierType == NSMIT_USERNAME_PRESENT &&
+	    usernamePresent) || usernameIdentifierType == NSMIT_USERNAME_NOT_PRESENT) &&
+	    (effectType == NSMET_USERNAME || effectType == NSMET_USERNAME_AND_IP))
+	{
+		if (addOrRemove)
+		{
+			// This is a list addition operation
+			if (!AddUsernameToList(SimpleUsername(username, m_LobbyAuth), tempListUsernames))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			else
+			{
+				resultUsernameEffectOnUsername = true;
+			}
+		}
+		else
+		{
+			// This is a list removal operation
+			if (!IsSimpleUsernameInList(username, listUsernames, m_LobbyAuth))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_IDENTIFIER_NOT_IN_LIST;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			// In fact, this temporary list represents a list of usernames to *remove* from
+			// the actual moderation list
+			if (!AddUsernameToList(SimpleUsername(username, m_LobbyAuth), tempListUsernames))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			else
+			{
+				resultUsernameEffectOnUsername = true;
+			}
+		}
+	}
+
+	// Clear any state from the above that might interfere with the following code
+	ResetModerationMessage(&moderationInfoFailed);
+	AddFieldsToModerationMessage(&moderationInfoFailed, action, false,
+	    NSMRT_INFO, NSMRC_FAILED, effectType);
+
+	// Process the provided IP for effect on IP
+	u32 integerIPToModerate = ENET_HOST_ANY;
+
+	if (!(ip.empty()) && (effectType == NSMET_IP || effectType == NSMET_USERNAME_AND_IP))
+	{
+		// convert string IP address to u32, then moderate it
+
+		integerIPToModerate = StunClient::u32ip_from_string(utf8_from_wstring(ip));
+		// LOGMESSAGE("u32ip_from_string() at line 1247 returned %016X", integerIPToModerate);
+
+		if (integerIPToModerate != ENET_HOST_ANY)
+		{
+			if (addOrRemove)
+			{
+				// This is a list addition operation
+				if (!AddIPToList(integerIPToModerate, tempListIPs))
+				{
+					if (interactive)
+					{
+						moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+						session->SendMessage(&moderationInfoFailed);
+					}
+					return false;
+				}
+				else
+				{
+					resultIPEffectOnIP = true;
+				}
+			}
+			else
+			{
+				// This is a list removal operation
+				if (!IsIPInList(integerIPToModerate, listIPs))
+				{
+					if (interactive)
+					{
+						moderationInfoFailed.m_ResponseCode = NSMRC_IDENTIFIER_NOT_IN_LIST;
+						session->SendMessage(&moderationInfoFailed);
+					}
+					return false;
+				}
+				// In fact, this temporary list represents a list of usernames to *remove* from
+				// the actual moderation list
+				if (!AddIPToList(integerIPToModerate, tempListIPs))
+				{
+					if (interactive)
+					{
+						moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+						session->SendMessage(&moderationInfoFailed);
+					}
+					return false;
+				}
+				else
+				{
+					resultIPEffectOnIP = true;
+				}
+			}
+		}
+		else
+		{
+			if (interactive)
+			{
+				moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+				session->SendMessage(&moderationInfoFailed);
+			}
+			return false;
+		}
+	}
+
+	// Clear any identifiers from the moderationInfoFailed message that may have
+	// been added above
+	ResetModerationMessage(&moderationInfoFailed);
+	AddFieldsToModerationMessage(&moderationInfoFailed, action, false,
+	    NSMRT_INFO, NSMRC_FAILED, effectType);
+
+	// Process the provided username for effect on IP
+	if (!(username.empty()) && (usernameIdentifierType == NSMIT_USERNAME_PRESENT &&
+	    usernamePresent) && (effectType == NSMET_IP ||
+	    effectType == NSMET_USERNAME_AND_IP))
+	{
+		if (addOrRemove)
+		{
+			if (!AddIPToList(IPAddressOfUsername, tempListIPs))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			else
+			{
+				// Intended effect completed.
+				// resultUsernameEffectOnIP = true;
+			}
+		}
+		else
+		{
+			// This is a list removal operation
+			if (!IsIPInList(IPAddressOfUsername, listIPs))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_IDENTIFIER_NOT_IN_LIST;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			// Add the IP to the list also, since this list represents a queue of IPs to
+			// *remove* from the actual list
+			if (!AddIPToList(IPAddressOfUsername, tempListIPs))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+			else
+			{
+				// resultUsernameEffectOnIP = true;
+			}
+		}
+	}
+
+	// Intentionally skipped cases: (one identifer of type NSMIT_IP and
+	// effectType NSMET_USERNAME).
+
+	// Check whether the transaction of usernames and IPs would restrict
+	// the controller
+	if (listIsRestrictive && addOrRemove)
+	{
+		CNetServerSession* controllerSession = GetControllerSession();
+		if (controllerSession)
+		{
+			const CStrW controllerSimpleUsername = SimpleUsername(controllerSession->GetUserName(), m_LobbyAuth);
+
+			// For each username in tempUsernameList
+			//     check whether the username matches the controller's username
+			//     if so then send error moderation response and return from function
+			if (std::any_of(tempListUsernames.begin(), tempListUsernames.end(),
+				[&](const CStrW& identifier)
+				{
+					return SimpleUsername(identifier, m_LobbyAuth) == controllerSimpleUsername;
+				}))
+			{
+				// Permission denied: Cannot restrict the host
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CANNOT_RESTRICT_HOST;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+
+			// For each IP in tempIPList
+			//      check whether the IP matches the controller's IP
+			//      if so then send error moderation response and return from function
+			u32 integerServerPublicIP = StunClient::u32ip_from_string(g_NetServer->GetPublicIp());
+			// LOGMESSAGE("u32ip_from_string() at line 1400 returned %016X", integerServerPublicIP);
+			u32 integerControllerSessionIP = session->GetIPAddress();
+			// LOGMESSAGE("u32ip_from_string() at line 1402 returned %016X", integerControllerSessionIP);
+			if (std::any_of(tempListIPs.begin(), tempListIPs.end(),
+				[&](const u32 identifier)
+				{
+					// Check against the host's public IP
+					return (integerServerPublicIP != ENET_HOST_ANY &&
+					    identifier == integerServerPublicIP) ||
+					// Check against the controller client's IP
+					    (integerControllerSessionIP != ENET_HOST_ANY &&
+					    identifier == integerControllerSessionIP);
+				}))
+			{
+				// Permission denied: Cannot restrict the host
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CANNOT_RESTRICT_HOST;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+		}
+	}
+
+	// Check whether additions to the list would exceed the maximum capacity
+	if (addOrRemove)
+	{
+		// This is a list addition
+		if (tempListUsernames.size() > 0  && (effectType == NSMET_USERNAME ||
+		    effectType == NSMET_USERNAME_AND_IP))
+		{
+			if(!IsSizeOfUsernameListsWithinMemoryLimit(tempListUsernames, listUsernames))
+
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+		}
+		if (tempListIPs.size() > 0 && (effectType == NSMET_IP ||
+		    effectType == NSMET_USERNAME_AND_IP))
+		{
+			if(!IsSizeOfIPListsWithinMemoryLimit(tempListIPs, listIPs))
+			{
+				if (interactive)
+				{
+					moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+					session->SendMessage(&moderationInfoFailed);
+				}
+				return false;
+			}
+		}
+	}
+
+	// If we have reached this point then all of the tests on the
+	// requested operations have passed. We can commit the updates to the
+	// actual moderation lists.
+
+	// Also prepare a moderation response message about each of the
+	// identifiers processed
+
+	ResetModerationMessage(&moderationInfoSuccess);
+	AddFieldsToModerationMessage(&moderationInfoSuccess, action, false,
+	    NSMRT_INFO, NSMRC_SUCCESS, effectType);
+
+	// Actually commit to the list the username parts of the transaction
+	bool nonTrivialUsernameResult = false;
+	if (effectType == NSMET_USERNAME || effectType == NSMET_USERNAME_AND_IP)
+	{
+		if (addOrRemove)
+		{
+			for (const CStrW& identifier : tempListUsernames)
+			{
+				// This is a list addition operation
+				if (!AddUsernameToList(identifier, listUsernames))
+				{
+					// Despite our attempts to prevent this situation, the additions still failed.
+					// Unfortunately this means that the operations were not all-or-nothing.
+					// Fortunately, this shouldn't happen if our checks in
+					// IsSizeOfUsernameListsWithinMemoryLimit() are equal or more conservative than
+					// the checks in AddUsernameToList.
+					if (interactive)
+					{
+						moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+						session->SendMessage(&moderationInfoFailed);
+					}
+					return false;
+				}
+				nonTrivialUsernameResult = true;
+			}
+		}
+		else
+		{
+			// This is a list removal operation
+			for (const CStrW& identifier : tempListUsernames)
+			{
+				// If the username isn't found in the list then the intended
+				// effects have already been accomplished
+				listUsernames.erase(std::remove(listUsernames.begin(), listUsernames.end(), identifier), listUsernames.end());
+				nonTrivialUsernameResult = true;
+			}
+		}
+	}
+
+	bool nonTrivialIPResult = false;
+	if (effectType == NSMET_IP || effectType == NSMET_USERNAME_AND_IP)
+	{
+		if (addOrRemove)
+		{
+			// This is a list addition operation
+			for (const u32 identifier : tempListIPs)
+			{
+				if (!AddIPToList(identifier, listIPs))
+				{
+					// Despite our attempts to prevent this situation, the additions still failed.
+					// Unfortunately this means that the operations were not all-or-nothing.
+					// Fortunately, this shouldn't happen if our checks in
+					// IsSizeOfIPListsWithinMemoryLimit() are equal or more conservative than the
+					// checks in AddUsernameToList.
+					if (interactive)
+					{
+						moderationInfoFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+						session->SendMessage(&moderationInfoFailed);
+					}
+					return false;
+				}
+				nonTrivialIPResult = true;
+			}
+		}
+		else
+		{
+			// This is a list removal operation
+			for (const u32 identifier : tempListIPs)
+			{
+				// If the identifier is not found then the intended
+				// effects have already been accomplished
+				listIPs.erase(std::remove(listIPs.begin(), listIPs.end(), identifier), listIPs.end());
+				nonTrivialIPResult = true;
+			}
+		}
+	}
+
+	bool kickResult = true;
+	// Kick the user if requested
+	if (action == NSMA_KICK || action == NSMA_KICK_BAN)
+	{
+		// Always announce kicks, regardless of requested response type. This way
+		// people don't think that kicked players disconnected voluntarily or due to
+		// technical difficulties
+		responseType = NSMRT_ANNOUNCEMENT;
+		kickResult = KickUser(username, interactive);
+	}
+
+	// Results were successful. Announce it.
+	if (kickResult && (nonTrivialUsernameResult || nonTrivialIPResult))
+	{
+		const CStrW& commandIssuer = session ? session->GetUserName() : L"";
+		if (username.empty())
+			usernameIdentifierType = NSMIT_UNUSED;
+		ReportModerationResults(context, interactive, userPrivilegeLevel ? true : false, action, responseType,
+		    NSMRC_SUCCESS, effectType, resultUsernameEffectOnUsername,
+		    userPrivilegeLevel && resultIPEffectOnIP, !(GUIDOfUsername.empty()),
+		    usernameIdentifierType, username, wstring_from_utf8(StunClient::string_from_u32ip(integerIPToModerate)),
+		    GUIDOfUsername, commandIssuer);
+		// LOGMESSAGE("string_from_u32ip() at line 1568 returned %s", StunClient::string_from_u32ip(integerIPToModerate));
+		return true;
+	}
+	else
+	{
+		// Error moderation responses are already handled by KickUser()
+		return false;
+	}
+
+}
+
+void CNetServerWorker::OutputModerationList(void* context, const size_t inputMessageSize, const bool interactiveRequested,
+    const bool userPrivilegeLevel, const u8 action, u8 responseType,
+    const u8 effectType, const std::vector<CStrW>& listUsernames,
+    const std::vector<u32>& listIPs)
+{
+	CNetServerSession *session = (CNetServerSession *)context;
+
+	const bool interactive{session != NULL && interactiveRequested};
+
+	if (responseType == NSMRT_ANNOUNCEMENT)
+	{
+		// Auto-adjust the responseType to INFO for list
+		// output, as it's only used by moderators and will
+		// be sent directly to the command issuer instead of broadcast
+		responseType = NSMRT_INFO;
+	}
+	else if (responseType != NSMRT_INFO && responseType != NSMRT_SILENT)
+	{
+		// Invalid response type. Silently drop the request. This shouldn't be reachable code because Moderation() checks for this case and returns early
+		LOGWARNING("CNetServerWorker::OutputModerationList: Invalid moderation response type. This shouldn't be reachable code.");
+		return;
+	}
+
+	// Note that Moderation() sets interactive to false when response
+	// type is silent. We will output the list, but we will not output
+	// error messages
+
+	CModerationMessage moderationMessageSuccess;
+	AddFieldsToModerationMessage(&moderationMessageSuccess, action, false,
+	    responseType, NSMRC_LIST, effectType);
+	CModerationMessage moderationMessageFailed;
+	AddFieldsToModerationMessage(&moderationMessageFailed, action, false,
+	    responseType, NSMRC_FAILED, effectType);
+		
+	if (!userPrivilegeLevel && action != NSMA_LIST_MUTE && effectType != NSMET_USERNAME)
+	{
+		// Permission denied, don't provide the list output
+		if (interactive)
+		{
+			moderationMessageFailed.m_ResponseCode = NSMRC_PERMISSION_DENIED;
+			session->SendMessage(&moderationMessageFailed);
+		}
+		return;
+	}
+
+	if (effectType != NSMET_IP && effectType != NSMET_USERNAME && effectType != NSMET_USERNAME_AND_IP)
+	{
+		// Invalid effect type
+		if (interactive)
+		{
+			moderationMessageFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+			session->SendMessage(&moderationMessageFailed);
+		}
+		return;
+	}
+
+	const bool outputUsernames = effectType == NSMET_USERNAME ||
+	    effectType == NSMET_USERNAME_AND_IP;
+	const bool outputIPs = userPrivilegeLevel && (effectType == NSMET_IP ||
+	    effectType == NSMET_USERNAME_AND_IP);
+
+	if (!IsSizeOfModerationListsWithinNetworkLimit(outputUsernames,
+	    outputIPs, listUsernames, listIPs))
+	{
+		if (interactive)
+		{
+			moderationMessageFailed.m_ResponseCode = NSMRC_CAPACITY_EXCEEDED;
+			session->SendMessage(&moderationMessageFailed);
+		}
+		return;
+	}
 
-	// and return if no one or the host has that name
-	if (it == m_Sessions.end() || (*it)->GetGUID() == m_ControllerGUID)
+	if (outputUsernames)
+		AddUsernameListToModerationMessage(&moderationMessageSuccess,
+		    listUsernames);
+	if (outputIPs)
+		AddIPListToModerationMessage(&moderationMessageSuccess, listIPs);
+
+	// Require equal or greater filler data to the list output, within a threshold
+	// of 20 bytes, to resist network query amplification
+	const size_t sizeOfModerationMessageSuccess = moderationMessageSuccess.GetSerializedLength();
+	if ((sizeOfModerationMessageSuccess > 20) &&
+	    (sizeOfModerationMessageSuccess - 20 > inputMessageSize))
+	{
+		if (interactive)
+		{
+			moderationMessageFailed.m_ResponseCode = NSMRC_INSUFFICIENT_FILLER_DATA;
+			session->SendMessage(&moderationMessageFailed);
+		}
 		return;
+	}
+	else
+	{
+		session->SendMessage(&moderationMessageSuccess);
+	}
+}
+
+
+
+void CNetServerWorker::AddFieldsToModerationMessage(CNetMessage* message, const u8 action, const u8 actionIsCommand,
+    const u8 responseType, const u8 responseCode, const u8 effectType)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	moderationMessage->m_Action = action;
+	moderationMessage->m_ActionIsCommand = actionIsCommand;
+	moderationMessage->m_ResponseType = responseType;
+	moderationMessage->m_ResponseCode = responseCode;
+	moderationMessage->m_EffectType = effectType;
+}
+
+void CNetServerWorker::AddIdentifierToModerationMessage(CNetMessage* message, const u8 identifierType, const CStrW& identifier)
+{
+	// Note that this is not idempotent. It will add more and more identifiers
+	// unless the identifier list is cleared at some point.
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	CModerationMessage::S_m_Identifiers identifierPair;
+	identifierPair.m_IdentifierType = identifierType;
+	identifierPair.m_Identifier = identifier;
+	moderationMessage->m_Identifiers.push_back(identifierPair);
+}
+
+CNetServerSession* CNetServerWorker::GetControllerSession()
+{
+	std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
+		[&](CNetServerSession* session)
+		{
+			return session->GetGUID() == m_ControllerGUID;
+		} );
+	return (it == m_Sessions.end()) ? nullptr : *it;
+}
+
+bool CNetServerWorker::IsIPInList(const u32 ipAddress, const std::vector<u32>& list)
+{
+	return std::find(list.begin(), list.end(), ipAddress) != list.end();
+}
+
+bool CNetServerWorker::IsSimpleUsernameInList(const CStrW& username, const std::vector<CStrW>& list, const bool lobbyAuth)
+{
+	const CStrW usernameToFind = SimpleUsername(username, lobbyAuth);
+	return std::any_of(list.begin(), list.end(),
+		[&](const CStrW tempUsername)
+		{
+			return SimpleUsername(tempUsername, lobbyAuth) == usernameToFind;
+		});
+
+	return std::find(list.begin(), list.end(), username) != list.end();
+}
+
+void CNetServerWorker::ResetModerationMessage(CNetMessage* message)
+{
+	ENSURE(message->GetType() == NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = static_cast<CModerationMessage *>(message);
+	moderationMessage->m_Action = NSMA_MUTE;
+	moderationMessage->m_ActionIsCommand = 0; /* false */
+	moderationMessage->m_ResponseType = NSMRT_SILENT;
+	moderationMessage->m_ResponseCode = NSMRC_FAILED;
+	moderationMessage->m_EffectType = NSMET_USERNAME;
+	moderationMessage->m_Identifiers.clear();
+}
+
+std::tuple<CStrW, u8, CStrW> CNetServerWorker::RetrieveFirstUsernameAndIPFromIdentifiers(const std::vector<CModerationMessage::S_m_Identifiers>& identifiers)
+{
+	CStrW username = L"";
+	u8 usernameIdentifierType = NSMIT_USERNAME_PRESENT;
+	CStrW ip = L"";
+
+	for(const CModerationMessage::S_m_Identifiers& identifierPair : identifiers)
+	{
+		// After we have one of each type, we can stop looking
+		if (!ip.empty() && !username.empty())
+			break;
+
+		switch (identifierPair.m_IdentifierType)
+		{
+		case NSMIT_IP:
+			if (ip.empty())
+				ip = identifierPair.m_Identifier;
+			break;
+		case NSMIT_USERNAME_PRESENT:
+		case NSMIT_USERNAME_NOT_PRESENT:
+			if (username.empty())
+			{
+				username = identifierPair.m_Identifier;
+				usernameIdentifierType = identifierPair.m_IdentifierType;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+	return std::tuple<CStrW, u8, CStrW>{username, usernameIdentifierType, ip};
+}
+
+CStrW CNetServerWorker::SimpleUsername(const CStrW& username, const bool lobbyAuth)
+{
+	return lobbyAuth ? CStrW(username.substr(0, username.find(L" ("))).LowerCase() : username.LowerCase();
+}
+
+/* Begin private moderation functions */
+
+void CNetServerWorker::AddIPListToModerationMessage(CNetMessage* message, const std::vector<u32>& listIPs)
+{
+	// Note that we assume that the other fields are being initialized in
+	// a different scope
+
+	ENSURE(message->GetType() == (uint)NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = (CModerationMessage*)message;
+
+	for (u32 ipAddress : listIPs)
+	{
+		// LOGMESSAGE("string_from_u32ip() at line 1795 returned %s", StunClient::string_from_u32ip(ipAddress));
+		CStrW ipString(wstring_from_utf8(StunClient::string_from_u32ip(ipAddress)));
+		AddIdentifierToModerationMessage(moderationMessage, NSMIT_IP, ipString);
+	}
+}
+
 
-	if (ban)
+bool CNetServerWorker::AddIPToList(u32 ipAddress, std::vector<u32>& list)
+{
+	if (ipAddress == ENET_HOST_ANY)
 	{
-		// Remember name
-		if (std::find(m_BannedPlayers.begin(), m_BannedPlayers.end(), playerName) == m_BannedPlayers.end())
-			m_BannedPlayers.push_back(m_LobbyAuth ? CStrW(playerName.substr(0, playerName.find(L" ("))) : playerName);
-
-		// Remember IP address
-		u32 ipAddress = (*it)->GetIPAddress();
-		if (std::find(m_BannedIPs.begin(), m_BannedIPs.end(), ipAddress) == m_BannedIPs.end())
-			m_BannedIPs.push_back(ipAddress);
-	}
-
-	// Disconnect that user
-	(*it)->Disconnect(ban ? NDR_BANNED : NDR_KICKED);
-
-	// Send message notifying other clients
-	CKickedMessage kickedMessage;
-	kickedMessage.m_Name = playerName;
-	kickedMessage.m_Ban = ban;
-	Broadcast(&kickedMessage, { NSS_PREGAME, NSS_JOIN_SYNCING, NSS_INGAME });
+		// Invalid IP address. Return error.
+		return false;
+	}
+
+	if (list.size() > MODERATION_MAX_LIST_ENTRIES - 1)
+		return false;
+
+	// Remember IP address if it's not remembered already
+	if (std::find(list.begin(), list.end(), ipAddress) == list.end())
+	{
+		list.push_back(ipAddress);
+	}
+
+	// Either the addition was successful, or the intended effects are
+	// already present
+	return true;
 }
 
+void CNetServerWorker::AddUsernameListToModerationMessage(CNetMessage* message, const std::vector<CStrW>& listUsernames)
+{
+	// Note that we assume that the other fields are being initialized in
+	// a different scope
+
+	ENSURE(message->GetType() == (uint)NMT_MODERATION);
+
+	CModerationMessage* moderationMessage = (CModerationMessage*)message;
+
+	for(const CStrW& username : listUsernames)
+	{
+		AddIdentifierToModerationMessage(moderationMessage,
+		    NSMIT_USERNAME_NOT_PRESENT, username);
+	}
+}
+
+bool CNetServerWorker::AddUsernameToList(const CStrW& identifier, std::vector<CStrW>& list)
+{
+	if (identifier.empty())
+	{
+		// Trivial operation. Intended effect completed.
+		return true;
+	}
+
+	// Only perform minimal checks here, since the caller is expected to
+	// check whether all of the templist elements would fit in the actual
+	// moderation list by calling IsSizeOfUsernameListsWithinMemoryLimit()
+
+	if (list.size() > MODERATION_MAX_LIST_ENTRIES - 1 ||
+	    identifier.length() >= MODERATION_MAX_LIST_MEMORY_USAGE)
+		return false;
+
+	if (std::find(list.begin(), list.end(), identifier.LowerCase()) == list.end())
+	{
+		list.push_back(identifier);
+	}
+
+	// Either the addition was successful, or the intended effects are
+	// already present
+	return true;
+}
+
+bool CNetServerWorker::IsSizeOfModerationListsWithinNetworkLimit(const bool useUsernames, const bool useIPs,
+    const std::vector<CStrW>& listUsernames, const std::vector<u32>& listIPs)
+{
+	const CModerationMessage emptyMessage;
+	const size_t sizeOfEmptyMessage{emptyMessage.GetSerializedLength()};
+
+	if (sizeOfEmptyMessage >= MODERATION_MAX_NETWORK_USAGE)
+		return false;
+	const size_t moderationMaxListNetworkUsage = MODERATION_MAX_NETWORK_USAGE - sizeOfEmptyMessage;
+
+	const size_t usernameListNetworkUsage{useUsernames ? SizeOfUsernameListInNetwork(listUsernames) : 0};
+	const size_t ipListNetworkUsage{useIPs ? SizeOfIPListInNetwork(listIPs) : 0};
+
+	return IsSizeOfDataWithinLimits(listUsernames.size(), usernameListNetworkUsage, listIPs.size(), ipListNetworkUsage,
+	    MODERATION_MAX_LIST_ENTRIES, moderationMaxListNetworkUsage);
+}
+
+bool CNetServerWorker::IsSizeOfDataWithinLimits(const size_t numEntriesList1, const size_t size1, const size_t numEntriesList2,
+    const size_t size2, const size_t entryLimit, const size_t sizeLimit)
+{
+	// Typically one would use MODERATION_MAX_LIST_ENTRIES for entryLimit
+	// and use MODERATION_MAX_LIST_MEMORY_USAGE for sizeLimit
+	//  or, use MODERATION_MAX_NETWORK_USAGE - emptymoderationmessage->GetSerializedLength() for sizeLimit for list
+	//  or, use MODERATION_MAX_NETWORK_USAGE for sizeLimit for CModerationMessage
+	if (numEntriesList1 > entryLimit ||
+	    numEntriesList2 > entryLimit - numEntriesList1)
+		return false;
+
+	return (size1 < sizeLimit && size2 < sizeLimit && size1 < sizeLimit - size2);
+}
+
+bool CNetServerWorker::IsSizeOfIdentifiersWithinNetworkLimit(const bool useUsername, const bool useIP, const bool useCommandIssuer,
+    const CStrW& username, const CStrW& ipAddressString, const CStrW& commandIssuer)
+{
+	const CModerationMessage emptyMessage;
+	const size_t sizeOfEmptyMessage = emptyMessage.GetSerializedLength();
+
+	if (sizeOfEmptyMessage >= MODERATION_MAX_NETWORK_USAGE)
+		return false;
+	const size_t moderationMaxListNetworkUsage = MODERATION_MAX_NETWORK_USAGE - sizeOfEmptyMessage;
+
+	// A username has username.size() wide (16-bit) characters, then a null
+	// terminator byte, then two bytes for an IdentifierType.
+
+	size_t usernameSize = 0;
+	size_t IPSize = 0;
+	size_t commandIssuerSize = 0;
+
+	if (useUsername)
+	{
+		usernameSize = username.size();
+		if (usernameSize >= (SIZE_MAX - 3) /2)
+			return false;
+		usernameSize = usernameSize * 2 + 3;
+	}
+
+	if (useCommandIssuer)
+	{
+		commandIssuerSize = commandIssuer.size();
+		if (commandIssuerSize >= (SIZE_MAX - 3) /2)
+			return false;
+		commandIssuerSize = commandIssuerSize * 2 + 3;
+		if (usernameSize >= SIZE_MAX - commandIssuerSize)
+			return false;
+		usernameSize += commandIssuerSize;
+	}
+
+	// Calculate the network data size of the IP address. An
+	// IP address is communicated as wide (16-bit) characters,
+	// then a null terminator byte, then two bytes for an IdentifierType
+
+	if (useIP)
+	{
+		IPSize = ipAddressString.size();
+		if (IPSize >= (SIZE_MAX - 3) /2)
+			return false;
+		IPSize = IPSize * 2 + 3;
+	}
+
+	return IsSizeOfDataWithinLimits((useUsername ? 1 : 0) + (useCommandIssuer ? 1 : 0), usernameSize, useIP ? 1 : 0,
+	    IPSize, MODERATION_MAX_LIST_ENTRIES, moderationMaxListNetworkUsage);
+}
+
+bool CNetServerWorker::IsSizeOfUsernameListsWithinMemoryLimit(const std::vector<CStrW>& listUsernames1, const std::vector<CStrW>& listUsernames2)
+{
+	const size_t sizeOfFirstListInMemory = SizeOfUsernameListInMemory(listUsernames1);
+	const size_t sizeOfSecondListInMemory = SizeOfUsernameListInMemory(listUsernames2);
+	return IsSizeOfDataWithinLimits(listUsernames1.size(), sizeOfFirstListInMemory, listUsernames2.size(), sizeOfSecondListInMemory,
+	    MODERATION_MAX_LIST_ENTRIES, MODERATION_MAX_LIST_MEMORY_USAGE);
+}
+
+bool CNetServerWorker::IsSizeOfIPListsWithinMemoryLimit(const std::vector<u32>& listIPs1, const std::vector<u32>& listIPs2)
+{
+	const size_t sizeOfFirstListInMemory = SizeOfIPListInMemory(listIPs1);
+	const size_t sizeOfSecondListInMemory = SizeOfIPListInMemory(listIPs2);
+	return IsSizeOfDataWithinLimits(listIPs1.size(), sizeOfFirstListInMemory, listIPs2.size(), sizeOfSecondListInMemory,
+	    MODERATION_MAX_LIST_ENTRIES, MODERATION_MAX_LIST_MEMORY_USAGE);
+}
+
+void CNetServerWorker::ReportModerationResults(void* context, const bool interactive, const bool userPrivilegeLevel,
+    const u8 action, const u8 responseType, const u8 responseCode,
+    const u8 effectType, const bool useUsername, const bool useIP,
+    const bool useGUID, const u8 usernameIdentifierType, const CStrW& username,
+    const CStrW& ipAddressString, const CStrW& GUID, const CStrW& commandIssuer)
+{
+	CNetServerSession* session = (CNetServerSession *)context;
+
+	CModerationMessage moderationInfoFailed;
+	AddFieldsToModerationMessage(&moderationInfoFailed, action, false,
+	    responseType, NSMRC_FAILED, effectType);
+
+	CModerationMessage moderationInfoResult;
+	// Prepare an info response which will be used to notify the
+	// command issuer, and maybe the controller, of the results
+	if (useUsername || useIP)
+	{
+		AddFieldsToModerationMessage(&moderationInfoResult, action, false, NSMRT_INFO, responseCode, effectType);
+		if (IsSizeOfIdentifiersWithinNetworkLimit(false, false, true, L"", L"", commandIssuer))
+			AddIdentifierToModerationMessage(&moderationInfoResult, NSMIT_USERNAME_COMMAND_ISSUER, commandIssuer);
+		if (responseCode == NSMRC_SUCCESS &&
+		    IsSizeOfIdentifiersWithinNetworkLimit(useUsername, useIP, true, username, ipAddressString, commandIssuer))
+		{
+			if (useUsername)
+				AddIdentifierToModerationMessage(&moderationInfoResult,
+				    usernameIdentifierType, username);
+			if (useIP)
+				AddIdentifierToModerationMessage(&moderationInfoResult,
+				    NSMIT_IP, ipAddressString);
+			if (useGUID)
+				AddIdentifierToModerationMessage(&moderationInfoResult,
+				    NSMIT_GUID, GUID);
+		}
+	}
+
+	if (interactive)
+	{
+		if(responseCode == NSMRC_SUCCESS && useUsername && responseType == NSMRT_ANNOUNCEMENT)
+		{
+			// Prepare and send an announcement of successful moderation command completion
+			if (!(username.empty()) &&
+			    IsSizeOfIdentifiersWithinNetworkLimit(true, false, false, username, L"", L""))
+			{
+				CModerationMessage moderationAnnouncementSuccess;
+				AddFieldsToModerationMessage(&moderationAnnouncementSuccess, action, false,
+				    responseType, responseCode, effectType);
+				AddIdentifierToModerationMessage(&moderationAnnouncementSuccess,
+				    usernameIdentifierType, username);
+				if (useGUID)
+					AddIdentifierToModerationMessage(&moderationAnnouncementSuccess,
+					    NSMIT_GUID, GUID);
+				Broadcast(&moderationAnnouncementSuccess, { NSS_PREGAME, NSS_JOIN_SYNCING, NSS_INGAME });
+			}
+		}
+
+		// Send info to command issuer with more detailed results. At this
+		// point the operation was either successful or trivial (no valid identifiers)
+		if (useUsername || useIP)
+		{
+			if (responseType == NSMRT_ANNOUNCEMENT ||
+			    responseType == NSMRT_INFO)
+				session->SendMessage(&moderationInfoResult);
+		}
+		else
+		{
+			if (interactive)
+			{
+				moderationInfoFailed.m_ResponseCode = NSMRC_SYNTAX_ERROR;
+				session->SendMessage(&moderationInfoFailed);
+			}
+			return;
+		}
+
+	}
+
+	// If some part of the command was successful and the
+	// commandIssuer was not the controller then, regardless
+	// of the response type, also send info to the controller.
+	// This way, a helper can't hide changes to the mute list
+	// from the host
+	if (responseCode == NSMRC_SUCCESS && !userPrivilegeLevel)
+	{
+		CNetServerSession* theSession = GetControllerSession();
+		moderationInfoResult.m_ResponseType = NSMRT_INFO;
+		if(theSession)
+			theSession->SendMessage(&moderationInfoResult);
+	}
+}
+
+size_t CNetServerWorker::SizeOfUsernameListInNetwork(const std::vector<CStrW>& listUsernames)
+{
+	// Calculate the maximum data size of the list of usernames. Each
+	// username has username.size() wide (16-bit) characters, then a null
+	// terminator byte, then two bytes for an IdentifierType.
+
+	return SizeOfUsernameList(0, 2, 3, listUsernames);
+}
+
+size_t CNetServerWorker::SizeOfIPListInNetwork(const std::vector<u32>& listIPs)
+{
+	// Calculate the maximum data size of the list of IP addresses. Each
+	// IP address is communicated as a string of wide (16-bit) characters,
+	// then a null terminator byte, then two bytes for an IdentifierType.
+
+	return SizeOfIPList(0, 2, 3, listIPs);
+}
+
+size_t CNetServerWorker::SizeOfUsernameListInMemory(const std::vector<CStrW>& listUsernames)
+{
+	// For the username list, assume that there are three 8-byte pointers,
+	// a vector size_type length, and for each element there is an 8-byte
+	// pointer to each string consisting of a (size_type) length, and
+	// 4 bytes for each character
+	return SizeOfUsernameList(24 + sizeof(std::vector<CStrW>::size_type), 4,
+	    8 + sizeof(std::string::size_type), listUsernames);
+}
+
+size_t CNetServerWorker::SizeOfIPListInMemory(const std::vector<u32>& listIPs)
+{
+	// For the IP list, assume that there are three 8-byte pointers,
+	// a size_type length, and a 4-byte IP address for each data element
+	return SizeOfIPList(24 + sizeof(std::vector<u32>::size_type), 0, 4, listIPs);
+}
+
+size_t CNetServerWorker::SizeOfUsernameList(const unsigned int usernameListOverhead,
+    const unsigned int usernameLengthFactor, const unsigned int usernameOverhead,
+    const std::vector<CStrW>& listUsernames)
+{
+	size_t result = usernameListOverhead;
+	for (const CStrW& username : listUsernames)
+	{
+		size_t previousSize = result;
+		// Guard against integer overflow of the calculation
+		if(!(username.size() < SIZE_MAX / usernameLengthFactor - usernameOverhead))
+			return SIZE_MAX;
+		result += usernameOverhead;
+		result += usernameLengthFactor * username.size();
+		// Guard against integer overflow of result by ensuring
+		// monotonically increasing result
+		if(result < previousSize)
+			return SIZE_MAX;
+	}
+
+	return result;
+}
+
+size_t CNetServerWorker::SizeOfIPList(const unsigned int IPListOverhead, const unsigned int IPLengthFactor,
+    const unsigned int IPOverhead, const std::vector<u32>& listIPs)
+{
+	// TODO: If IPv6 is supported then replace 15 with 2 * max character length of the string representation of an IP address
+	if(!(listIPs.size() < (SIZE_MAX - IPListOverhead) / (IPLengthFactor * 15 + IPOverhead)))
+		return SIZE_MAX;
+
+	const size_t result = IPListOverhead + (IPLengthFactor * 15 + IPOverhead) * listIPs.size();
+
+	return result;
+}
+
+/* End private moderation functions */
+
 void CNetServerWorker::AssignPlayer(int playerID, const CStr& guid)
 {
 	// Remove anyone who's already assigned to this player
@@ -1002,6 +2268,15 @@
 		return true;
 	}
 
+	// Disconnect banned usernames before checking the password so that
+	// they can't use side channel analysis to try to crack the password.
+	// Banned IPs were already disconnected in HandleConnect()
+	if (std::find(server.m_BannedUsers.begin(), server.m_BannedUsers.end(), server.m_LobbyAuth ? usernameWithoutRating.LowerCase() : username.LowerCase()) != server.m_BannedUsers.end())
+	{
+		session->Disconnect(NDR_BANNED);
+		return true;
+	}
+
 	// Check the password before anything else.
 	// NB: m_Name must match the client's salt, @see CNetClient::SetGamePassword
 	if (!server.CheckPassword(message->m_Password, message->m_Name.ToUTF8()))
@@ -1036,12 +2311,10 @@
 		}
 	}
 
-	// Disconnect banned usernames
-	if (std::find(server.m_BannedPlayers.begin(), server.m_BannedPlayers.end(), server.m_LobbyAuth ? usernameWithoutRating : username) != server.m_BannedPlayers.end())
-	{
-		session->Disconnect(NDR_BANNED);
-		return true;
-	}
+	// If the IP of the user that just connected is on the mute list then
+	// add that user's name to the list of muted users.
+	if (std::find(server.m_MutedIPs.begin(), server.m_MutedIPs.end(), session->GetIPAddress()) != server.m_MutedIPs.end())
+		server.AddUsernameToList(SimpleUsername(username, server.m_LobbyAuth), server.m_MutedUsers);
 
 	int maxObservers = 0;
 	CFG_GET_VAL("network.observerlimit", maxObservers);
@@ -1245,7 +2518,15 @@
 
 	message->m_GUID = session->GetGUID();
 
-	server.Broadcast(message, { NSS_PREGAME, NSS_INGAME });
+	const CStrW username = SimpleUsername(session->GetUserName(), server.m_LobbyAuth);
+
+	// If the user is not in the muted list then broadcast the chat
+	// message sent by the user
+	// Adding a check against the user's IP address in the list of muted
+	// IPs would make things confusing for lobby helpers because they would
+	// not see the user in the mute list.
+	if (!server.IsSimpleUsernameInList(username, server.m_MutedUsers, server.m_LobbyAuth))
+		server.Broadcast(message, { NSS_PREGAME, NSS_INGAME });
 
 	return true;
 }
@@ -1447,16 +2728,42 @@
 
 bool CNetServerWorker::OnKickPlayer(void* context, CFsmEvent* event)
 {
-	ENSURE(event->GetType() == (uint)NMT_KICKED);
+	// This function is deprecated. Stub it out until the network protocol
+	// is updated to remove this message type
+	return false;
+}
+
+bool CNetServerWorker::OnModeration(void* context, CFsmEvent* event)
+{
+	ENSURE(event->GetType() == (uint)NMT_MODERATION);
 
 	CNetServerSession* session = (CNetServerSession*)context;
 	CNetServerWorker& server = session->GetServer();
 
-	if (session->GetGUID() == server.m_ControllerGUID)
+	CModerationMessage* message = (CModerationMessage*)event->GetParamRef();
+
+	if (message->m_ActionIsCommand)  /* conforming a u8 to boolean (nonzero is true) */
 	{
-		CKickedMessage* message = (CKickedMessage*)event->GetParamRef();
-		server.KickPlayer(message->m_Name, message->m_Ban);
+		const u8 action = message->m_Action;
+		const size_t inputMessageSize = (action == NSMA_LIST_BAN || action == NSMA_LIST_MUTE || action == NSMA_LIST_HELPER) ? message->GetSerializedLength() : 0;
+		// Allow the controller full access to moderation capabilities
+		if (session->GetGUID() == server.m_ControllerGUID)
+		{
+			server.Moderation(context, inputMessageSize, true, message->m_Action, message->m_ResponseType, message->m_EffectType, message->m_Identifiers);
+		}
+		else
+		{
+			const CStrW username = session->GetUserName();
+			const u32 ipAddress = session->GetIPAddress();
+			if ((!(username.empty()) && server.IsSimpleUsernameInList(username, server.m_HelperUsers, server.m_LobbyAuth)) || (ipAddress != ENET_HOST_ANY && server.IsIPInList(ipAddress, server.m_HelperIPs)))
+			{
+				// Allow designated helpers to mute or unmute players and retrieve the list of
+				// muted users (names only)
+				server.Moderation(context, inputMessageSize, false, message->m_Action, message->m_ResponseType, message->m_EffectType, message->m_Identifiers);
+			}
+		}
 	}
+
 	return true;
 }
 
@@ -1691,14 +2998,40 @@
 	if (it == m_FailedAttempts.end())
 		m_FailedAttempts.emplace(username, 1);
 	else
+	{
 		it->second++;
+		if(it->second > FAILED_PASSWORD_TRIES_BEFORE_BAN)
+		{
+			// If the password check failed more than X times then ban the user
+			std::lock_guard<std::mutex> lock(m_Worker->m_WorkerMutex);
+			// Search through the list of sessions to find the controller's session, and
+			// use that as the context for the notification about the ban
+			CNetServerSession* context = m_Worker->GetControllerSession();
+			const CStrW usernameWide = wstring_from_utf8(username);
+			// TODO: test case that context == nullptr.
+
+			if (context)
+			{
+				std::vector<CModerationMessage::S_m_Identifiers> identifiers;
+				CModerationMessage::S_m_Identifiers identifierPair;
+				identifierPair.m_IdentifierType = NSMIT_USERNAME_NOT_PRESENT;
+				identifierPair.m_Identifier = m_Worker->SimpleUsername(usernameWide, m_LobbyAuth);
+				identifiers.push_back(identifierPair);
+				m_Worker->UpdateModerationList(context, true, true, NSMA_BAN,
+				    NSMRT_INFO, NSMET_USERNAME, identifiers, true, true,
+				    m_Worker->m_BannedUsers, m_Worker->m_BannedIPs);
+			}
+		}
+	}
+
 	return false;
 }
 
 bool CNetServer::IsBanned(const std::string& username) const
 {
-	std::unordered_map<std::string, int>::const_iterator it = m_FailedAttempts.find(username);
-	return it != m_FailedAttempts.end() && it->second >= FAILED_PASSWORD_TRIES_BEFORE_BAN;
+	std::lock_guard<std::mutex> lock(m_Worker->m_WorkerMutex);
+
+	return m_Worker->IsSimpleUsernameInList(wstring_from_utf8(username), m_Worker->m_BannedUsers, m_LobbyAuth);
 }
 
 void CNetServer::SetPassword(const CStr& password)
Index: source/network/StunClient.h
===================================================================
--- source/network/StunClient.h
+++ source/network/StunClient.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2021 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * Copyright (C) 2013-2016 SuperTuxKart-Team.
  * This file is part of 0 A.D.
  *
@@ -48,6 +48,36 @@
  * Technically not a STUN method, but convenient to define here.
  */
 bool FindLocalIP(CStr8& ip);
+
+/**
+ * Check whether the linked version of libenet is equal to or greater than the
+ * version in the arguments.
+ * Technically not a STUN method, but convenient to define here.
+ * @return true if the version of libenet is sufficient. false otherwise.
+ */
+bool CheckENetVersionSufficient(u8 major, u8 minor, u8 patch);
+
+/**
+ * Convert a string-based IP address to a u32 integer IP address, suitable for
+ * comparison with a moderation list or use with ENet
+ * Technically not a STUN method, but convenient to define here.
+ * @param identifier a username, IP address or other type of user identifier.
+ * @return on success, 32-bit integer representing the IP address that is
+ * compatible with ENet and sockets addr.host format. on error, ENET_HOST_ANY.
+ */
+u32 u32ip_from_string(const CStr& identifier);
+
+
+/**
+ * Convert a u32 integer-based IP address to a string-based IP address,
+ * suitable for output in a CModerationMessage
+ * Technically not a STUN method, but convenient to define here.
+ * @param ipAddress an integer representation of an IP address, compatible
+ *                  with ENet and sockets addr.host format
+ * @return on success, wide string representing the IP address
+ *         on error, empty (wide) string
+ */
+CStr string_from_u32ip(const u32 ipAddress);
 }
 
 #endif // STUNCLIENT_H
Index: source/network/StunClient.cpp
===================================================================
--- source/network/StunClient.cpp
+++ source/network/StunClient.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * Copyright (C) 2013-2016 SuperTuxKart-Team.
  * This file is part of 0 A.D.
  *
@@ -26,6 +26,14 @@
 #include "ps/ConfigDB.h"
 #include "ps/CStr.h"
 
+#if !OS_WIN
+#ifndef ENET_HAVE_ENET_ADDRESS_SET_HOST_IP
+#include <sys/types.h>   /* for getaddrinfo() */
+#include <sys/socket.h>  /* for getaddrinfo() */
+#include <netdb.h>       /* for getaddrinfo() */
+#endif
+#endif
+
 #include <chrono>
 #include <cstddef>
 #include <thread>
@@ -400,4 +408,89 @@
 
 	return true;
 }
+
+bool CheckENetVersionSufficient(u8 major, u8 minor, u8 patch)
+{
+	ENetVersion theEnetVersion = enet_linked_version();
+	const u8 theEnetVersionMajor = ENET_VERSION_GET_MAJOR(theEnetVersion);
+	const u8 theEnetVersionMinor = ENET_VERSION_GET_MINOR(theEnetVersion);
+	const u8 theEnetVersionPatch = ENET_VERSION_GET_PATCH(theEnetVersion);
+	if ((theEnetVersionMajor > major) || ((theEnetVersionMajor == major) &&
+	    ((theEnetVersionMinor > minor) || ((theEnetVersionMinor == minor) &&
+	    (theEnetVersionPatch >= patch)))))
+		return true;
+	else
+		return false;
+}
+
+CStr string_from_u32ip(const u32 ipAddress)
+{
+	// convert numeric IP address to string
+	ENetAddress addr;
+	addr.host = ipAddress;
+	addr.port = 0;
+	char buf[50];
+	if (enet_address_get_host_ip(&addr, buf, ARRAY_SIZE(buf)) == -1)
+		return CStr("");
+	return CStr(buf);
+}
+
+u32 u32ip_from_string(const CStr& identifier)
+{
+	const char* stringIP = identifier.c_str();
+	u32 integerIP;
+
+#ifdef ENET_HAVE_ENET_ADDRESS_SET_HOST_IP
+	integerIP = ENET_HOST_ANY;   /* default is invalid connect host, 0.0.0.0 */
+
+	// libenet version was 1.3.14 or higher at compile-time. Use
+	// enet_address_set_host_ip if the actually-linked version of libenet
+	// is also that version or higher
+
+	if(StunClient::CheckENetVersionSufficient(1, 3, 14));
+	{
+		ENetAddress addr;
+		if (enet_address_set_host_ip(&addr, stringIP) >= 0)
+			integerIP = addr.host;
+	}
+
+#else
+#if OS_WIN
+#error Missing enet_address_set_host_ip. Upgrade libenet to version 1.3.14 or higher
+#endif
+	struct addrinfo* result;
+	struct addrinfo hints;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;    /* Allow IPv4 only for now */
+	hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
+	hints.ai_flags = NI_NUMERICHOST | NI_NUMERICSERV;  /* prevent DNS lookup */
+	hints.ai_protocol = 0;          /* Any protocol */
+	if (getaddrinfo(stringIP, NULL, &hints, &result) != 0)
+		return ENET_HOST_ANY;
+	
+	// Although getaddrinfo() may return multiple address structures,
+	// use only the first one. If the caller needs more than one then
+	// the caller should use getaddrinfo() directly.
+
+	if (result == NULL)
+		return ENET_HOST_ANY;
+
+	integerIP = ENET_HOST_ANY;
+
+	if (result->ai_family == AF_INET)
+	{
+		// Interpret the socket structure as an IPv4 socket structure
+		struct sockaddr_in* theInaddrPtr = (sockaddr_in*)result->ai_addr;
+		integerIP = theInaddrPtr->sin_addr.s_addr;
+
+	}
+
+	freeaddrinfo(result);
+
+#endif
+
+	return integerIP;
+}
+
 }
Index: source/network/scripting/JSInterface_Network.cpp
===================================================================
--- source/network/scripting/JSInterface_Network.cpp
+++ source/network/scripting/JSInterface_Network.cpp
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2023 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -235,6 +235,40 @@
 	g_NetClient->SendKickPlayerMessage(playerName, ban);
 }
 
+void Moderation(const ScriptInterface& scriptInterface, const u8 action, const u8 actionIsCommand, const u8 responseType, const u8 responseCode, const u8 effectType, JS::HandleValue identifiers)
+{
+	ENSURE(g_NetClient);
+
+	CModerationMessage moderationMessage;
+	g_NetClient->ResetModerationMessage(&moderationMessage);
+	g_NetClient->AddFieldsToModerationMessage(&moderationMessage, action, actionIsCommand, responseType, responseCode, effectType);
+
+	ScriptRequest rq(scriptInterface);
+	if(!identifiers.isNull() && JS_TypeOfValue(rq.cx, identifiers) == JSTYPE_OBJECT)
+	{
+		for(u8 i = 0; i < MODERATION_MAX_LIST_ENTRIES; i++)
+		{
+			std::string iString = CStr::FromUInt(i);
+			if(Script::HasProperty(rq, identifiers, iString.c_str()))
+			{
+				JS::RootedValue identifierPair(rq.cx);
+				Script::GetProperty(rq, identifiers, iString.c_str(), &identifierPair);
+				if(!identifiers.isNull() && Script::HasProperty(rq, identifierPair, "identifierType") && Script::HasProperty(rq, identifierPair, "identifier"))
+				{
+					u32 identifierType;
+					Script::GetProperty(rq, identifierPair, "identifierType", identifierType);
+					std::wstring identifier;
+					Script::GetProperty(rq, identifierPair, "identifier", identifier);
+					if(identifier.length() > 0)
+						g_NetClient->AddIdentifierToModerationMessage(&moderationMessage, static_cast<u8>(identifierType), static_cast<const CStrW>(CStrW(identifier)));
+				}
+			}
+		}
+	}
+
+	g_NetClient->SendModerationMessage(&moderationMessage);
+}
+
 void SendNetworkChat(const CStrW& message)
 {
 	ENSURE(g_NetClient);
@@ -289,6 +323,7 @@
 	ScriptFunction::Register<&SendGameSetupMessage>(rq, "SendGameSetupMessage");
 	ScriptFunction::Register<&AssignNetworkPlayer>(rq, "AssignNetworkPlayer");
 	ScriptFunction::Register<&KickPlayer>(rq, "KickPlayer");
+	ScriptFunction::Register<&Moderation>(rq, "Moderation");
 	ScriptFunction::Register<&SendNetworkChat>(rq, "SendNetworkChat");
 	ScriptFunction::Register<&SendNetworkReady>(rq, "SendNetworkReady");
 	ScriptFunction::Register<&ClearAllPlayerReady>(rq, "ClearAllPlayerReady");