Index: binaries/data/config/default.cfg
===================================================================
--- binaries/data/config/default.cfg
+++ binaries/data/config/default.cfg
@@ -156,6 +156,11 @@
 lobby = "Alt+L"                          ; Show the multiplayer lobby in a dialog window.
 structree = "Alt+Shift+T"                ; Show structure tree
 civinfo = "Alt+Shift+H"                  ; Show civilization info
+hostgame = "H"                  ; Open the dialog to host a match
+joingame = "J"                  ; Join the selected lobby match or open the dialog to enter an IP address to join
+networkstats = "N" ; Open the dialog that shows the network statistics of the connected clients
+previousPage = "P" ; Presses the "return" button, which leads one back to the previous menu
+                   ; This is different from the "close dialog" hotkey which doesn't change the root page but only closes a child page
 
 ; > CLIPBOARD CONTROLS
 copy = "Ctrl+C"                       ; Copy to clipboard
@@ -453,6 +458,10 @@
 observerlimit = 8                 ; Prevent further observer joins in running games if this limit is reached
 gamestarttimeout = 60000          ; Don't disconnect clients timing out in the loading screen and rejoin process before exceeding this timeout.
 
+[network.geolite2]
+enabled = true;                   ; Whether or not to load the local GeoLite2 database, if it exists.
+directory = "geolite2/"           ; directory that contains the GeoLite2 databse. Obtainable at https://dev.maxmind.com/geoip/geoip2/
+
 [overlay]
 fps = "false"                     ; Show frames per second in top right corner
 realtime = "false"                ; Show current system time in top right corner
Index: binaries/data/mods/public/gui/common/NetworkDialogManager.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/common/NetworkDialogManager.js
@@ -0,0 +1,28 @@
+function NetworkDialogManager()
+{
+	this.guiPage = undefined;
+}
+
+NetworkDialogManager.prototype.open = function()
+{
+	this.guiPage = Engine.PushGuiPage("page_networkreport.xml", {
+		"gameAttributes": g_GameAttributes,
+		"playerAssignments": g_PlayerAssignments,
+		"callback": "closePageHack" // TODO: should use D1684
+	});
+};
+
+function closePageHack()
+{
+	if (typeof g_NetworkDialogManager != "undefined")
+		g_NetworkDialogManager.guiPage = undefined;
+}
+
+NetworkDialogManager.prototype.refresh = function()
+{
+	if (this.guiPage)
+		this.guiPage.updatePage({
+			"gameAttributes": g_GameAttributes,
+			"playerAssignments": g_PlayerAssignments,
+		});
+};
Index: binaries/data/mods/public/gui/common/color.js
===================================================================
--- binaries/data/mods/public/gui/common/color.js
+++ binaries/data/mods/public/gui/common/color.js
@@ -75,6 +75,15 @@
 }
 
 /**
+ * @param {Number} efficiency - between 0 and 1
+ * @returns {String} GUI color representing efficiency, 1 yields green, 0.5 yellow and 0 red.
+ */
+function efficiencyToColor(efficiency)
+{
+	return hslToRgb(Math.min(1, Math.max(0, efficiency)) / 3, 1, 0.5).join(" ");
+}
+
+/**
  * Convert color value from RGB to HSL space.
  *
  * @see {@link https://stackoverflow.com/questions/2353211/hsl-to-rgb-color-conversion}
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
@@ -1,40 +1,22 @@
 /**
- * Number of milliseconds to display network warnings.
+ * Latency at which the game performance becomes impaired.
  */
-var g_NetworkWarningTimeout = 3000;
+const inefficientRTT = Engine.GetTurnLength();
 
 /**
- * Currently displayed network warnings. At most one message per user.
+ * Ratio at which the game performance becomes impaired.
  */
-var g_NetworkWarnings = {};
+const inefficientPacketLoss = 0.25;
 
 /**
- * Message-types to be displayed.
+ * Number of milliseconds to display network warnings.
  */
-var g_NetworkWarningTexts = {
+var g_NetworkWarningTimeout = 3000;
 
-	"server-timeout": (msg, username) =>
-		sprintf(translate("Losing connection to server (%(seconds)ss)"), {
-			"seconds": Math.ceil(msg.lastReceivedTime / 1000)
-		}),
-
-	"client-timeout": (msg, username) =>
-		sprintf(translate("%(player)s losing connection (%(seconds)ss)"), {
-			"player": username,
-			"seconds": Math.ceil(msg.lastReceivedTime / 1000)
-		}),
-
-	"server-latency": (msg, username) =>
-		sprintf(translate("Bad connection to server (%(milliseconds)sms)"), {
-			"milliseconds": msg.meanRTT
-		}),
-
-	"client-latency": (msg, username) =>
-		sprintf(translate("Bad connection to %(player)s (%(milliseconds)sms)"), {
-			"player": username,
-			"milliseconds": msg.meanRTT
-		})
-};
+/**
+ * Currently displayed network reports. At most one message per user.
+ */
+var g_NetworkWarnings = {};
 
 var g_NetworkCommands = {
 	"/kick": argument => kickPlayer(argument, false),
@@ -81,6 +63,42 @@
 }
 
 /**
+ * @param {bool} isLocal - Whether this is a remote client or our connection.
+ * @param {Object} performance - The performance data of a remote client passed by the NetClient.
+ * @returns the String
+ */
+function getNetworkWarningString(isLocal, performance)
+{
+	if (performance.lastReceivedTime > 3000)
+		return isLocal ?
+			translate("Losing connection to server (%(seconds)ss)") :
+			translate("%(player)s losing connection (%(seconds)ss)");
+
+	if (performance.meanRTT > inefficientRTT)
+		return isLocal ?
+			translate("Bad connection to server (%(milliseconds)sms)") :
+			translate("Bad connection to %(player)s (%(milliseconds)sms)");
+
+	if (performance.packetLoss > inefficientPacketLoss)
+		return isLocal ?
+			translate("Bad connection to server (%(packetLossRatio)s%% packet loss)") :
+			translate("Bad connection to %(player)s (%(packetLossRatio)s%% packet loss)");
+
+	return "";
+}
+
+function getNetworkWarningText(string, performance, username)
+{
+	return sprintf(string, {
+		"player": username,
+		"seconds": Math.ceil(performance.lastReceivedTime / 1000),
+		"milliseconds": performance.meanRTT,
+		"packetLossRatio": (performance.packetLoss * 100).toFixed(1)
+	})
+}
+
+
+/**
  * Show the disconnect reason in a message box.
  *
  * @param {number} reason
@@ -110,7 +128,7 @@
 
 function kickPlayer(username, ban)
 {
-	if (g_IsController)
+	if (Engine.HasNetServer())
 		Engine.KickPlayer(username, ban);
 	else
 		kickError();
@@ -118,7 +136,7 @@
 
 function kickObservers(ban)
 {
-	if (!g_IsController)
+	if (!Engine.HasNetServer())
 	{
 		kickError();
 		return;
@@ -185,26 +203,28 @@
 }
 
 /**
- * Remember this warning for a few seconds.
- * Overwrite previous warnings for this user.
- *
- * @param msg - GUI message sent by NetServer or NetClient
+ * Creates a report for each network client with a critically bad network connection to be displayed for some duration.
  */
-function addNetworkWarning(msg)
+function pollNetworkWarnings()
 {
-	if (!g_NetworkWarningTexts[msg.warntype])
-	{
-		warn("Unknown network warning type received: " + uneval(msg));
+	if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") != "true")
 		return;
-	}
 
-	if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") != "true")
+	let clientPerformance = Engine.GetNetworkClientPerformance();
+	if (!clientPerformance)
 		return;
 
-	g_NetworkWarnings[msg.guid || "server"] = {
-		"added": Date.now(),
-		"msg": msg
-	};
+	for (let guid in clientPerformance)
+	{
+		let string = getNetworkWarningString(guid == Engine.GetPlayerGUID(), clientPerformance[guid]);
+
+		if (string)
+			g_NetworkWarnings[guid] = {
+				"added": Date.now(),
+				"string": string,
+				"performance":  clientPerformance[guid]
+			};
+	}
 }
 
 /**
@@ -213,14 +233,19 @@
  */
 function getNetworkWarnings()
 {
+	if (Engine.ConfigDB_GetValue("user", "overlay.netwarnings") != "true")
+		return {
+			"messages": [],
+			"maxTextWidth": 0
+		};
+
 	// Remove outdated messages
 	for (let guid in g_NetworkWarnings)
-		if (Date.now() > g_NetworkWarnings[guid].added + g_NetworkWarningTimeout ||
-		    guid != "server" && !g_PlayerAssignments[guid])
+		if (Date.now() > g_NetworkWarnings[guid].added + g_NetworkWarningTimeout || !g_PlayerAssignments[guid])
 			delete g_NetworkWarnings[guid];
 
 	// Show local messages first
-	let guids = Object.keys(g_NetworkWarnings).sort(guid => guid != "server");
+	let guids = Object.keys(g_NetworkWarnings).sort(guid => guid != Engine.GetPlayerGUID());
 
 	let font = Engine.GetGUIObjectByName("gameStateNotifications").font;
 
@@ -229,14 +254,11 @@
 
 	for (let guid of guids)
 	{
-		let msg = g_NetworkWarnings[guid].msg;
-
 		// Add formatted text
-		messages.push(g_NetworkWarningTexts[msg.warntype](msg, colorizePlayernameByGUID(guid)));
+		messages.push(getNetworkWarningText(g_NetworkWarnings[guid].string, g_NetworkWarnings[guid].performance, colorizePlayernameByGUID(guid)));
 
 		// Add width of unformatted text
-		let username = guid != "server" && g_PlayerAssignments[guid].name;
-		let textWidth = Engine.GetTextWidth(font, g_NetworkWarningTexts[msg.warntype](msg, username));
+		let textWidth = Engine.GetTextWidth(font, getNetworkWarningText(g_NetworkWarnings[guid].string, g_NetworkWarnings[guid].performance, g_PlayerAssignments[guid].name));
 		maxTextWidth = Math.max(textWidth, maxTextWidth);
 	}
 
Index: binaries/data/mods/public/gui/gamesetup/gamesetup.js
===================================================================
--- binaries/data/mods/public/gui/gamesetup/gamesetup.js
+++ binaries/data/mods/public/gui/gamesetup/gamesetup.js
@@ -12,6 +12,8 @@
 
 var g_GameSpeeds = getGameSpeedChoices(false);
 
+var g_NetworkDialogManager = new NetworkDialogManager();
+
 /**
  * Offer users to select playable civs only.
  * Load unselectable civs as they could appear in scenario maps.
@@ -140,7 +142,6 @@
  */
 var g_NetMessageTypes = {
 	"netstatus": msg => handleNetStatusMessage(msg),
-	"netwarn": msg => addNetworkWarning(msg),
 	"gamesetup": msg => handleGamesetupMessage(msg),
 	"players": msg => handlePlayerAssignmentMessage(msg),
 	"ready": msg => handleReadyMessage(msg),
@@ -1063,6 +1064,13 @@
 		},
 		"hidden": () => !Engine.HasXmppClient()
 	},
+	"networkButton": {
+		"onPress": () => function() {
+			if (g_IsNetworked)
+				g_NetworkDialogManager.open();
+		},
+		"hidden": () => !g_IsNetworked
+	},
 	"spTips": {
 		"hidden": () => {
 			let settingsPanel = Engine.GetGUIObjectByName("settingsPanel");
@@ -1405,7 +1413,7 @@
 	let settingTabButtons = Engine.GetGUIObjectByName("settingTabButtons");
 	let settingTabButtonsSize = settingTabButtons.size;
 	settingTabButtonsSize.bottom = settingTabButtonsSize.top + g_SettingsTabsGUI.length * (g_TabButtonHeight + g_TabButtonDist);
-	settingTabButtonsSize.right = g_MiscControls.lobbyButton.hidden() ?
+	settingTabButtonsSize.right = (g_MiscControls.lobbyButton.hidden() && g_MiscControls.networkButton.hidden()) ?
 		settingTabButtonsSize.right :
 		Engine.GetGUIObjectByName("lobbyButton").size.left - g_LobbyButtonSpacing;
 	settingTabButtons.size = settingTabButtonsSize;
@@ -1572,6 +1580,8 @@
 
 	updateGUIObjects();
 
+	g_NetworkDialogManager.refresh();
+
 	hideLoadingWindow();
 }
 
@@ -1605,6 +1615,8 @@
 		sendRegisterGameStanzaImmediate();
 	else
 		sendRegisterGameStanza();
+
+	g_NetworkDialogManager.refresh();
 }
 
 function onClientJoin(newGUID, newAssignments)
@@ -1996,6 +2008,7 @@
 		handleNetMessages();
 
 	updateTimers();
+	pollNetworkWarnings();
 
 	let now = Date.now();
 	let tickLength = now - g_LastTickTime;
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
@@ -202,6 +202,20 @@
 				<translatableAttribute id="tooltip">Show the multiplayer lobby in a dialog window.</translatableAttribute>
 			</object>
 
+			<!-- View Network Button -->
+			<!-- TODO: new icon -->
+			<object name="networkButton"
+				type="button"
+				style="IconButton"
+				sprite="iconInfoGold"
+				sprite_over="iconInfoWhite"
+				size="100%-41 378 100%-25 394"
+				hotkey="networkstats"
+				z="100"
+			>
+				<translatableAttribute id="tooltip">Show the network dialog.</translatableAttribute>
+			</object>
+
 			<!-- Map Description -->
 			<object name="mapInfoDescriptionFrame" type="image" sprite="ModernDarkBoxGold" size="100%-315 550 100%-25 100%-60" z="21">
 				<object name="mapInfoDescription" type="text" style="ModernText" size="0 0 100% 100%"/>
@@ -256,6 +270,7 @@
 				size="100%-308 100%-52 100%-168 100%-24"
 				tooltip_style="onscreenToolTip"
 				z="21"
+				hotkey="previousPage"
 			>
 				<translatableAttribute id="caption">Back</translatableAttribute>
 				<action on="Press">cancelSetup();</action>
Index: binaries/data/mods/public/gui/lobby/lobby_panels.xml
===================================================================
--- binaries/data/mods/public/gui/lobby/lobby_panels.xml
+++ binaries/data/mods/public/gui/lobby/lobby_panels.xml
@@ -153,13 +153,13 @@
 				<object name="sgPlayersNames" size="0 0 100% 100%" type="text" style="MapPlayerList"/>
 			</object>
 		</object>
-		<object name="joinGameButton" type="button" style="ModernButtonRed" size="0 100%-79 100% 100%-54" hidden="true">
+		<object name="joinGameButton" type="button" style="ModernButtonRed" size="0 100%-79 100% 100%-54" hotkey="joingame" hidden="true">
 			<translatableAttribute id="caption" comment="Join the game currently selected in the list.">Join Game</translatableAttribute>
 			<action on="Press">
 				joinButton();
 			</action>
 		</object>
-		<object name="hostButton" type="button" style="ModernButtonRed" size="0 100%-52 100% 100%-27">
+		<object name="hostButton" type="button" style="ModernButtonRed" size="0 100%-52 100% 100%-27" hotkey="hostgame">
 			<translatableAttribute id="caption">Host Game</translatableAttribute>
 			<action on="Press">
 				hostGame();
Index: binaries/data/mods/public/gui/networkreport/ClientList.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/ClientList.js
@@ -0,0 +1,168 @@
+function ClientList(guiObjectName)
+{
+	this.geoLite2 = new GeoLite2Cache();
+	this.clientList = Engine.GetGUIObjectByName(guiObjectName);
+	this.updateInterval = 1000;
+	this.lastUpdate = 0;
+	this.countryFlags = new CountryFlags(14, 14, true);
+	this.selectedGUID = undefined;
+}
+
+// TODO: missing hotload
+ClientList.prototype.OnTick = function(gameAttributes, playerAssignments)
+{
+	let now = Date.now();
+	if (now <= this.lastUpdate + this.updateInterval)
+		return false;
+
+	this.UpdateList(gameAttributes, playerAssignments);
+	this.lastUpdate = now;
+	return true;
+};
+
+ClientList.prototype.UpdateList = function(gameAttributes, playerAssignments)
+{
+	let clientPerformance = Engine.GetNetworkClientPerformance();
+	if (!clientPerformance)
+		return;
+
+	let guids = Object.keys(clientPerformance).filter(guid => !!playerAssignments[guid]).sort((guid1, guid2) =>
+		this.clientList.selected_column_order *
+		this.GetListEntryOrder(playerAssignments)[this.clientList.selected_column](guid1, guid2, clientPerformance));
+
+	// TODO: It would be nicer and safer to exchange the entire table at a time
+	let clientListEntries = prepareForDropdown(guids.map(guid => this.GetListEntry(gameAttributes, playerAssignments, guid, clientPerformance[guid])));
+
+	let selectedGUID = this.SelectedGUID();
+
+	for (let column in clientListEntries)
+		//if (("list_" + column) in clientList) TODO: this shouldn't make it crash
+		if (column != "Default")
+			this.clientList["list_" + column] = clientListEntries[column];
+	this.clientList.list = guids;
+	this.clientList.selected = this.clientList.list.indexOf(selectedGUID);
+};
+
+ClientList.prototype.SelectedGUID = function()
+{
+	return this.clientList.list[this.clientList.selected] || undefined;
+};
+
+/**
+ * Notice that the "this" keyword refers to a different object depending
+ */
+ClientList.prototype.GetListEntry = function(gameAttributes, playerAssignments, guid, clientPerformance)
+{
+	// TODO: this scope should not exist, but "this" references are difficult
+	return {
+		"name":
+			setStringTags(playerAssignments[guid].name, {
+				"color": (() => {
+					let playerID = playerAssignments[guid].player - 1;
+					return gameAttributes.settings.PlayerData[playerID] ? rgbToGuiColor(gameAttributes.settings.PlayerData[playerID].Color) : "white";
+				})()
+			}),
+
+		"status":
+			getNetworkWarningText(
+				getNetworkWarningString(guid == Engine.GetPlayerGUID(), clientPerformance),
+				clientPerformance,
+				playerAssignments[guid].name) || translate("Ok"),
+		"ipAddress": Engine.GetClientIPAddress(guid),
+
+		"hostname": Engine.LookupClientHostname(guid),
+
+		"isp": (() => {
+			let geoLite2 = this.geoLite2.GetByGUID(guid);
+			return geoLite2 && geoLite2.autonomousSystemOrganization || translateWithContext("unknown internet service provider", "?");
+		})(),
+
+		"location": (() => {
+			let geoLite2 = this.geoLite2.GetByGUID(guid);
+
+			if (!geoLite2)
+				return translateWithContext("unknown country", "?");
+
+			// TODO: Test for icon existence and use different string if it doesn't exist
+			// TODO: icon for satellite (no country / global) ISP and anonymous / VPN
+			return sprintf(
+				geoLite2.cityName ?
+					translate("%(icon)s %(continent)s/%(country)s/%(city)s (±%(accuracyRadius)skm)") :
+					translate("%(icon)s %(continent)s/%(country)s"),
+				{
+					"icon": iconTag(this.countryFlags.GetIconName(geoLite2.countryCode)),
+					"continent": geoLite2.continentName,
+					"country": geoLite2.countryName,
+					"city": geoLite2.cityName || "",
+					"accuracyRadius": geoLite2.accuracyRadius || ""
+				});
+		})(),
+
+		"time": (() => {
+			// TODO: Get time in timezone
+			let geoLite2 = this.geoLite2.GetByGUID(guid);
+			return geoLite2 && geoLite2.timeZone || "";
+		})(),
+
+		"meanRTT": (() => {
+			let lastReceivedTime = clientPerformance.lastReceivedTime > 3000 ? clientPerformance.lastReceivedTime : 0;
+			let meanRTT = Math.max(clientPerformance.meanRTT, lastReceivedTime);
+			return meanRTT == 0 ?
+				translateWithContext("unknown mean roundtriptime", "?") :
+				coloredText(
+					sprintf(translateWithContext("network latency", "%(milliseconds)sms"), {
+						"milliseconds": meanRTT
+					}),
+					efficiencyToColor(1 - meanRTT / inefficientRTT));
+		})(),
+
+		"packetLoss":
+			// TODO: 0 can also mean perfect connection, for example localhost.
+			clientPerformance.packetLoss == 0 ?
+				translateWithContext("unknown packet loss ratio", "?") :
+				coloredText(
+					sprintf(translateWithContext("network packet loss", "%(packetLossRatio)s%%"), {
+						"packetLossRatio": (clientPerformance.packetLoss * 100).toFixed(1)
+					}),
+					efficiencyToColor(1 - clientPerformance.packetLoss / inefficientPacketLoss))
+		};
+};
+
+ClientList.prototype.GetListEntryOrder = function(playerAssignments)
+{
+	return {
+		"name": (guid1, guid2) =>
+			playerAssignments[guid1].name.localeCompare(
+			playerAssignments[guid2].name),
+
+		"status": (guid1, guid2, clientPerformance) =>
+			getNetworkWarningString(guid1 == Engine.GetPlayerGUID(), clientPerformance[guid1]).localeCompare(
+			getNetworkWarningString(guid2 == Engine.GetPlayerGUID(), clientPerformance[guid2])),
+
+		"ipAddress": (guid1, guid2) =>
+			Engine.IPv4ToNumber(Engine.GetClientIPAddress(guid1)) - Engine.IPv4ToNumber(Engine.GetClientIPAddress(guid2)),
+
+		"hostname": (guid1, guid2) =>
+			Engine.LookupClientHostname(guid1).localeCompare(Engine.LookupClientHostname(guid2)),
+
+		"location": (guid1, guid2) => {
+			let getSortKey = geolite2 => geolite2 ? geolite2.continentName + "/" + geolite2.countryCode + "/" + (geolite2.cityCode || "") : "";
+			return getSortKey(this.geoLite2.GetByGUID(guid1)).localeCompare(getSortKey(this.geoLite2.GetByGUID(guid2)));
+		},
+
+		"isp": (guid1, guid2) =>
+			(this.geoLite2.GetByGUID(guid1) ? this.geoLite2.GetByGUID(guid1).autonomousSystemOrganization : "").localeCompare(
+			(this.geoLite2.GetByGUID(guid2) ? this.geoLite2.GetByGUID(guid2).autonomousSystemOrganization : "")),
+
+		"time": (guid1, guid2) =>
+			0, // TODO
+
+		"meanRTT": (guid1, guid2, clientPerformance) =>
+			clientPerformance[guid1].meanRTT -
+			clientPerformance[guid2].meanRTT,
+
+		"packetLoss": (guid1, guid2, clientPerformance) =>
+			clientPerformance[guid1].packetLoss -
+			clientPerformance[guid2].packetLoss
+	};
+};
Index: binaries/data/mods/public/gui/networkreport/CountryFlags.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/CountryFlags.js
@@ -0,0 +1,18 @@
+function CountryFlags(width = 16, height = 16, replaceExisting = true)
+{
+	let directory = "global/icon/flags/";
+
+	// TODO: displace tag?
+
+	for (let countryID of listFiles("art/textures/ui/" + directory, ".png", false))
+		Engine.AddIcon(
+			this.GetIconName(countryID),
+			"stretched:" + directory + countryID + ".png",
+			width + " " + height,
+			replaceExisting);
+}
+
+CountryFlags.prototype.GetIconName = function(countryCode)
+{
+	return "icon_country_" + countryCode.toLowerCase();
+};
Index: binaries/data/mods/public/gui/networkreport/GeoLite2.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/GeoLite2.js
@@ -0,0 +1,23 @@
+function GeoLite2Cache()
+{
+	this.geoLite2 = {};
+}
+
+GeoLite2Cache.prototype.GetByIP = function(ipAddress)
+{
+	// Also cache undefined return value
+	if (!(ipAddress in this.geoLite2))
+	{
+		this.geoLite2[ipAddress] = Engine.GetGeoLite2(ipAddress);
+
+		if (this.geoLite2[ipAddress])
+			deepfreeze(this.geoLite2[ipAddress]);
+	}
+
+	return this.geoLite2[ipAddress];
+};
+
+GeoLite2Cache.prototype.GetByGUID = function(guid)
+{
+	return this.GetByIP(Engine.GetClientIPAddress(guid));
+};
Index: binaries/data/mods/public/gui/networkreport/NetworkDialog.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/NetworkDialog.js
@@ -0,0 +1,100 @@
+// TODO: remember selected columns
+// TODO: sort players first
+// TODO: this should show whether the client is rejoining at the moment
+// TODO: display host
+// TODO: allow giving host controls to clients
+// TODO: allow muting clients
+// TODO: display if clients are too slow with the simulation
+
+function NetworkDialog(gameAttributes, playerAssignments)
+{
+	this.playerAssignments = playerAssignments;
+	this.gameAttributes = gameAttributes;
+	this.isController = Engine.HasNetServer();
+	this.clientList = new ClientList("clientList");
+
+	this.UpdateGUIObjects();
+}
+
+NetworkDialog.prototype.GetHotloadData = function()
+{
+	return {
+		"gameAttributes": this.gameAttributes,
+		"playerAssignments": this.playerAssignments
+	};
+};
+
+NetworkDialog.prototype.UpdateGameData = function(data)
+{
+	this.gameAttributes = data.gameAttributes;
+	this.playerAssignments = data.playerAssignments;
+
+	this.UpdateGUIObjects();
+};
+
+NetworkDialog.prototype.UpdateGUIObjects = function()
+{
+	this.clientList.UpdateList(this.gameAttributes, this.playerAssignments);
+	this.UpdateGUIProperties();
+};
+
+NetworkDialog.prototype.UpdateGUIProperties = function()
+{
+	let guiProperties = this.GetGUIProperties();
+	for (let objectName in guiProperties)
+		for (let propertyName in guiProperties[objectName])
+			Engine.GetGUIObjectByName(objectName)[propertyName] = guiProperties[objectName][propertyName];
+};
+
+NetworkDialog.prototype.GetGUIProperties = function()
+{
+	return {
+		"networkreport": {
+			"onTick": () => {
+				pollNetworkWarnings();
+			}
+		},
+		"clientList": {
+			"onSelectionColumnChange": () => {
+				this.UpdateGUIObjects();
+			},
+			"onSelectionChange": () => {
+				// onSelectionChange may not call UpdateList, otherwise infinite loop
+				this.UpdateGUIProperties();
+			},
+			// TODO: Support skip confirmation hotkey
+			"onMouseLeftDoubleClickItem": () => {
+				if (this.isController)
+					Engine.GetGUIObjectByName("kickButton").onPress();
+			},
+			"onTick": () => {
+				if (this.clientList.OnTick(this.gameAttributes, this.playerAssignments))
+					this.UpdateGUIProperties();
+			}
+		},
+		"kickButton": {
+			"caption": translate("Kick"),
+			"tooltip": translate("Disconnect this player immediately."),
+			"hidden": !this.isController,
+			"enabled":  this.clientList.SelectedGUID() && this.clientList.SelectedGUID() != Engine.GetPlayerGUID(),
+			"onPress": () => {
+				kickPlayer(this.playerAssignments[this.clientList.SelectedGUID()].name, false);
+			}
+		},
+		"banButton": {
+			"caption": translate("Ban"),
+			"tooltip": translate("Disconnect this player immediately and deny any request to rejoin."),
+			"hidden": !this.isController,
+			"enabled": this.clientList.SelectedGUID() && this.clientList.SelectedGUID() != Engine.GetPlayerGUID(),
+			"onPress": () => {
+				kickPlayer(this.playerAssignments[this.clientList.SelectedGUID()].name, true);
+			}
+		},
+		"closeButton": {
+			"caption": translate("Close"),
+			"onPress": () => {
+				Engine.PopGuiPageCB();
+			}
+		}
+	};
+};
Index: binaries/data/mods/public/gui/networkreport/networkreport.js
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/networkreport.js
@@ -0,0 +1,19 @@
+var g_NetworkDialog;
+
+// TODO: page_foo.xml instead of hardcoded global function names, it would be nicer to hardcode one JSClass/prototype name
+function init(data, hotloadData)
+{
+	g_NetworkDialog = new NetworkDialog(
+		hotloadData ? hotloadData.gameAttributes : data.gameAttributes,
+		hotloadData ? hotloadData.playerAssignments : data.playerAssignments);
+}
+
+function getHotloadData()
+{
+	return g_NetworkDialog.GetHotloadData();
+}
+
+function updatePage(data)
+{
+	g_NetworkDialog.UpdateGameData(data);
+}
Index: binaries/data/mods/public/gui/networkreport/networkreport.xml
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/networkreport/networkreport.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<objects>
+
+	<script directory="gui/common/"/>
+	<script directory="gui/networkreport/"/>
+
+	<object type="image" sprite="ModernFade"/>
+	<object name="networkreport" type="image" style="ModernDialog" size="10% 15% 90% 85%">
+
+		<object style="TitleText" type="text" size="50%-128 -16 50%+128 16">
+			<translatableAttribute id="caption">Network</translatableAttribute>
+		</object>
+
+		<object name="clientList"
+			type="olist"
+			style="ModernSortedList"
+			selected_column="name"
+			selected_column_order="1"
+			sortable="true"
+			size="15 40 100%-15 100%-60"
+			font="sans-bold-stroke-13"
+		>
+			<column id="name" color="0 128 128" width="10%">
+				<translatableAttribute id="heading">Name</translatableAttribute>
+			</column>
+
+			<column id="status" color="0 128 128" width="10%">
+				<translatableAttribute id="heading">Status</translatableAttribute>
+			</column>
+
+			<column id="ipAddress" color="0 128 128" width="6%">
+				<translatableAttribute id="heading">IP Address</translatableAttribute>
+			</column>
+
+			<column id="hostname" color="0 128 128" width="15%">
+				<translatableAttribute id="heading">Hostname</translatableAttribute>
+			</column>
+
+			<column id="isp" color="0 128 128" width="15%">
+				<translatableAttribute id="heading">Internet Provider</translatableAttribute>
+			</column>
+
+			<column id="location" color="0 128 128" width="20%">
+				<translatableAttribute id="heading">Location</translatableAttribute>
+			</column>
+
+			<column id="time" color="0 128 128" width="12%">
+				<translatableAttribute id="heading">Time</translatableAttribute>
+			</column>
+
+			<column id="meanRTT" color="0 128 128" width="6%">
+				<translatableAttribute id="heading">Ping</translatableAttribute>
+			</column>
+
+			<column id="packetLoss" color="0 128 128" width="6%">
+				<translatableAttribute id="heading">Packet Loss</translatableAttribute>
+			</column>
+		</object>
+
+		<object name="kickButton" type="button" style="ModernButtonRed" size="20 100%-48 170 100%-20"/>
+		<object name="banButton" type="button" style="ModernButtonRed" size="180 100%-48 330 100%-20"/>
+			<!-- TODO: skip confirmation hotkey -->
+		<object name="closeButton" type="button" style="ModernButtonRed" size="100%-170 100%-48 100%-20 100%-20" hotkey="cancel"/>
+	</object>
+
+</objects>
Index: binaries/data/mods/public/gui/options/options.json
===================================================================
--- binaries/data/mods/public/gui/options/options.json
+++ binaries/data/mods/public/gui/options/options.json
@@ -373,6 +373,19 @@
 		]
 	},
 	{
+		"label": "Network",
+		"tooltip": "Set options for multiplayer matches.",
+		"options":
+		[
+			{
+				"type": "boolean",
+				"label": "GeoLite2",
+				"tooltip": "Enable geolocation lookup of connected clients.",
+				"config": "network.geolite2.enabled"
+			}
+		]
+	},
+	{
 		"label": "Lobby",
 		"tooltip": "These settings only affect the multiplayer.",
 		"options":
Index: binaries/data/mods/public/gui/page_networkreport.xml
===================================================================
--- /dev/null
+++ binaries/data/mods/public/gui/page_networkreport.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<page>
+	<include>common/modern/setup.xml</include>
+	<include>common/modern/styles.xml</include>
+	<include>common/modern/sprites.xml</include>
+
+	<include>common/setup.xml</include>
+	<include>common/sprites.xml</include>
+	<include>common/styles.xml</include>
+
+	<include>networkreport/networkreport.xml</include>
+	<include>common/global.xml</include>
+</page>
Index: binaries/data/mods/public/gui/pregame/mainmenu.xml
===================================================================
--- binaries/data/mods/public/gui/pregame/mainmenu.xml
+++ binaries/data/mods/public/gui/pregame/mainmenu.xml
@@ -227,6 +227,7 @@
 					style="StoneButtonFancy"
 					size="0 0 100% 28"
 					tooltip_style="pgToolTip"
+					hotkey="joingame"
 				>
 					<translatableAttribute id="caption" comment="Join a game by specifying the host's IP address.">Join Game</translatableAttribute>
 					<translatableAttribute id="tooltip">Joining an existing multiplayer game.</translatableAttribute>
@@ -241,6 +242,7 @@
 					style="StoneButtonFancy"
 					size="0 32 100% 60"
 					tooltip_style="pgToolTip"
+					hotkey="hostgame"
 				>
 					<translatableAttribute id="caption">Host Game</translatableAttribute>
 					<translatableAttribute id="tooltip">Host a multiplayer game.\n\nRequires UDP port 20595 to be open.</translatableAttribute>
Index: binaries/data/mods/public/gui/session/menu.js
===================================================================
--- binaries/data/mods/public/gui/session/menu.js
+++ binaries/data/mods/public/gui/session/menu.js
@@ -2,7 +2,7 @@
 var MARGIN = 4;
 
 // Includes the main menu button
-const NUM_BUTTONS = 10;
+const NUM_BUTTONS = 11;
 
 // Regular menu buttons
 var BUTTON_HEIGHT = 32;
@@ -74,6 +74,8 @@
 // Redefined every time someone makes a tribute (so we can save some data in a closure). Called in input.js handleInputBeforeGui.
 var g_FlushTributing = function() {};
 
+var g_NetworkDialogManager = new NetworkDialogManager();
+
 function initMenu()
 {
 	Engine.GetGUIObjectByName("menu").size = "100%-164 " + MENU_TOP + " 100% " + MENU_BOTTOM;
Index: binaries/data/mods/public/gui/session/menu.xml
===================================================================
--- binaries/data/mods/public/gui/session/menu.xml
+++ binaries/data/mods/public/gui/session/menu.xml
@@ -99,11 +99,22 @@
 			<action on="Press">resignMenuButton();</action>
 		</object>
 
+		<!-- Network button -->
+		<object type="button"
+			style="StoneButtonFancy"
+			size="0 256 100% 284"
+			tooltip_style="sessionToolTip"
+			hotkey="networkstats"
+		>
+			<translatableAttribute id="caption">Network</translatableAttribute>
+			<action on="Press">g_NetworkDialogManager.open();</action>
+		</object>
+
 		<!-- Exit button -->
 		<object type="button"
 			name="menuExitButton"
 			style="StoneButtonFancy"
-			size="0 256 100% 256+28"
+			size="0 288 100% 316"
 			tooltip_style="sessionToolTip"
 		>
 			<translatableAttribute id="caption">Exit</translatableAttribute>
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
@@ -50,9 +50,6 @@
 	"netstatus": msg => {
 		handleNetStatusMessage(msg);
 	},
-	"netwarn": msg => {
-		addNetworkWarning(msg);
-	},
 	"out-of-sync": msg => {
 		onNetworkOutOfSync(msg);
 	},
@@ -757,6 +754,8 @@
 	updateGUIObjects();
 	updateChatAddressees();
 	sendLobbyPlayerlistUpdate();
+
+	g_NetworkDialogManager.refresh();
 }
 
 function onClientJoin(guid)
Index: binaries/data/mods/public/gui/session/session.js
===================================================================
--- binaries/data/mods/public/gui/session/session.js
+++ binaries/data/mods/public/gui/session/session.js
@@ -802,6 +802,7 @@
 	g_LastTickTime = now;
 
 	handleNetMessages();
+	pollNetworkWarnings();
 
 	updateCursorAndTooltip();
 
Index: source/gui/scripting/ScriptFunctions.cpp
===================================================================
--- source/gui/scripting/ScriptFunctions.cpp
+++ source/gui/scripting/ScriptFunctions.cpp
@@ -25,6 +25,7 @@
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "i18n/scripting/JSInterface_L10n.h"
 #include "lobby/scripting/JSInterface_Lobby.h"
+#include "network/scripting/JSInterface_GeoLite2.h"
 #include "network/scripting/JSInterface_Network.h"
 #include "ps/scripting/JSInterface_ConfigDB.h"
 #include "ps/scripting/JSInterface_Console.h"
@@ -58,6 +59,7 @@
 	JSI_GUIManager::RegisterScriptFunctions(scriptInterface);
 	JSI_Game::RegisterScriptFunctions(scriptInterface);
 	JSI_GameView::RegisterScriptFunctions(scriptInterface);
+	JSI_GeoLite2::RegisterScriptFunctions(scriptInterface);
 	JSI_L10n::RegisterScriptFunctions(scriptInterface);
 	JSI_Lobby::RegisterScriptFunctions(scriptInterface);
 	JSI_Main::RegisterScriptFunctions(scriptInterface);
Index: source/i18n/scripting/JSInterface_L10n.cpp
===================================================================
--- source/i18n/scripting/JSInterface_L10n.cpp
+++ source/i18n/scripting/JSInterface_L10n.cpp
@@ -24,6 +24,8 @@
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
+// TODO: country-code to language name
+
 // Returns a translation of the specified English string into the current language.
 std::wstring JSI_L10n::Translate(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::wstring& sourceString)
 {
Index: source/network/GeoLite2.h
===================================================================
--- /dev/null
+++ source/network/GeoLite2.h
@@ -0,0 +1,127 @@
+/* Copyright (C) 2019 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 GEOLITE2_H
+#define GEOLITE2_H
+
+#include "lib/file/vfs/vfs_path.h"
+#include "scriptinterface/ScriptInterface.h"
+
+#include <string>
+
+/**
+ * Identifies an IPv4 range as a parsed CIDR, i.e. an IPv4 in hostbyte order + Number of bits of the subnet mask.
+ */
+// TODO: Consider using u64 conversion to save space :/
+using IPv4SubnetKeyType = std::pair<u32, u8>;
+
+/**
+ * This class provides caching of the GeoLite2 database and query results using the systems inet.h.
+ * It uses caching to prevent reoccuring slow lookup times.
+ *
+ * GeoLite2 files:
+ *   The here supported GeoLite2 datasets are a GeoLite2-*Blocks*.csv and a GeoLite2-*Location.csv file.
+ *   The Blocks file maps from IPv4 or IPv6 subnet to the location ID and some properties about the ISP.
+ *   The Location file maps from a location ID to some properties about the location.
+ *   Both the Country and the City level are supported.
+ */
+class GeoLite2
+{
+public:
+	GeoLite2(const std::string& IETFLanguageTag);
+	~GeoLite2();
+
+	/**
+	 * Returns whether the user requested a class instance.
+	 */
+	static bool IsEnabled();
+
+	/**
+	 * Loads both the Blocks and the Locations file of the given IPv4.
+	 */
+	JS::Value GetIPv4Data(const ScriptInterface& scriptInterface, u32 ipAddress);
+
+private:
+
+	// Loads the user configured VFS directory from which the csv files will be loaded.
+	void LoadPath();
+
+	// Proxy calling LoadBlocksIPv4 and LoadLocations.
+	bool LoadContent(const std::string& content);
+
+	// Loads and parses the GeoLite2 Blocks csv file.
+	bool LoadBlocks(const std::string& content);
+
+	// Parses Country data of a City or Country Blocks file.
+	void ParseCountryBlocksLine(const std::string& subnet, const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values);
+	void ParseCityBlocksLine(const std::string& subnet, const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values);
+	void ParseASNBlocksLine(const std::string& subnet, const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values);
+
+	// Loads and parses the GeoLite2 Blocks csv file.
+	bool LoadLocations(const std::string& content);
+
+	// Loads a csv file and parses it as a vector of strings excluding the first line.
+	bool LoadCSVFile(const VfsPath& filePath, const std::string& expectedHeader, std::function<void(const std::vector<std::string>&)>& lineRead);
+
+	bool ParseGeonameID(const std::string& geoNameID, u32& geonameIDNum);
+	void ParseCityLocationsLine(const std::string& geonameID, const u32& geonameIDNum, const std::vector<std::string>& values);
+	void ParseCountryLocationsLine(const std::string& geonameID, const u32& geonameIDNum, const std::vector<std::string>& values);
+
+	/**
+	 * The directory that the user configured to load.
+	 */
+	VfsPath m_Path;
+
+	/**
+	 * This is the IETF code of language that should be loaded, for example "en", or "pt-BR" for brazilian portuguese.
+	 */
+	std::string m_IETFLanguageTag;
+
+	/**
+	 * Stores the header of the csv files of every content type. Used as an integrity test.
+	 */
+	static std::map<std::string, std::string> m_BlocksHeader;
+	static std::map<std::string, std::string> m_LocationsHeader;
+
+	// This discards a lot of less relevant data, because storing all strings of a City file would consume about 2GB.
+
+	// Country Blocks data
+	std::map<IPv4SubnetKeyType, u32> m_Blocks_IPv4_GeoID;
+	std::set<IPv4SubnetKeyType> m_Blocks_IPv4_Anonymous;
+	std::set<IPv4SubnetKeyType> m_Blocks_IPv4_Satellite;
+
+	// City Blocks data
+	std::map<IPv4SubnetKeyType, std::tuple<float, float, u16>> m_Blocks_IPv4_GeoCoordinates;
+
+	// ASN Blocks data
+	std::map<IPv4SubnetKeyType, u32> m_Blocks_IPv4_AutonomousSystemNumber;
+	std::map<u32, std::string> m_Blocks_IPv4_AutonomousSystemOrganization;
+
+	/**
+	 * Maps from geoname ID to Locations data.
+	 */
+	std::map<u32, std::string> m_CountryLocations_CountryCodes;
+	std::map<std::string, std::pair<std::string, std::string>> m_CountryLocations_CountryData;
+	std::map<u32, std::vector<std::string>> m_CityLocations;
+};
+
+/**
+ * Sneaky global.
+ */
+extern GeoLite2* g_GeoLite2;
+
+#endif // GEOLITE2_H
Index: source/network/GeoLite2.cpp
===================================================================
--- /dev/null
+++ source/network/GeoLite2.cpp
@@ -0,0 +1,450 @@
+/* Copyright (C) 2019 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/>.
+ */
+
+#include "precompiled.h"
+
+#include "GeoLite2.h"
+
+#include "lib/file/vfs/vfs_path.h"
+#include "network/IPTools.h"
+#include "ps/ConfigDB.h"
+#include "ps/Filesystem.h"
+#include "ps/CLogger.h"
+#include "scriptinterface/ScriptInterface.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+// TODO: Support IPv6
+// TODO: implement a thread to load, the City file consumes 14 seconds to load!
+
+GeoLite2* g_GeoLite2 = nullptr;
+
+GeoLite2::GeoLite2(const std::string& IETFLanguageTag)
+: m_IETFLanguageTag(IETFLanguageTag)
+{
+	LoadPath();
+
+	if (!LoadContent("City") && !LoadContent("Country"))
+		LOGERROR("Could not load GeoLite2 city nor country data!");
+
+	LoadBlocks("ASN");
+}
+
+GeoLite2::~GeoLite2()
+{
+}
+
+bool GeoLite2::IsEnabled()
+{
+	bool enabled = true;
+	CFG_GET_VAL("network.geolite2.enabled", enabled);
+	return enabled;
+}
+
+void GeoLite2::LoadPath()
+{
+	std::string path;
+	CFG_GET_VAL("network.geolite2.directory", path);
+	m_Path = path;
+}
+
+bool GeoLite2::LoadContent(const std::string& content)
+{
+	return LoadBlocks(content) && LoadLocations(content);
+}
+
+std::map<std::string, std::string> GeoLite2::m_BlocksHeader = {
+	{ "Country", "network,geoname_id,registered_country_geoname_id,represented_country_geoname_id,is_anonymous_proxy,is_satellite_provider" },
+	{ "City", "network,geoname_id,registered_country_geoname_id,represented_country_geoname_id,is_anonymous_proxy,is_satellite_provider,postal_code,latitude,longitude,accuracy_radius" },
+	{ "ASN", "network,autonomous_system_number,autonomous_system_organization" }
+};
+
+std::map<std::string, std::string> GeoLite2::m_LocationsHeader = {
+	{ "Country", "geoname_id,locale_code,continent_code,continent_name,country_iso_code,country_name,is_in_european_union" },
+	{ "City", "geoname_id,locale_code,continent_code,continent_name,country_iso_code,country_name,subdivision_1_iso_code,subdivision_1_name,subdivision_2_iso_code,subdivision_2_name,city_name,metro_code,time_zone,is_in_european_union" }
+};
+
+/**
+ * Load
+ *   GeoLite2-City-Blocks-IPv4.csv or
+ *   GeoLite2-Country-Blocks-IPv4.csv or
+ *   GeoLite2-ASN-Blocks-IPv4.csv.
+ *
+ * The City filesize can exceed 150MB. Storing it as a string vector can consume 2GB+!
+ * Therefore the data must be stored as numbers and bools where possible.
+ *
+ * Example Country:
+ *   network,geoname_id,registered_country_geoname_id,represented_country_geoname_id,is_anonymous_proxy,is_satellite_provider
+ *   92.222.251.176/28,3017382,3017382,,0,0
+ *
+ * Example City:
+ *   network,geoname_id,registered_country_geoname_id,represented_country_geoname_id,is_anonymous_proxy,is_satellite_provider,postal_code,latitude,longitude,accuracy_radius
+ *   38.88.98.0/23,6075357,6252001,,0,0,L5J,43.5102,-79.6296,500
+ *
+ * Example ASM:
+ *   network,autonomous_system_number,autonomous_system_organization
+ *   88.198.0.0/16,24940,"Hetzner Online GmbH"
+ */
+bool GeoLite2::LoadBlocks(const std::string& content)
+{
+	VfsPath filePath(m_Path / ("GeoLite2-" + content + "-Blocks-IPv4.csv"));
+
+	std::function<void(const std::vector<std::string>& values)> readLine = [this, content](const std::vector<std::string>& values)
+	{
+		if (values.size() < 1)
+			return;
+
+		// Parse subnet
+		const std::string& subnet = values.at(0);
+		u32 subnetAddress;
+		u8 subnetMaskBits;
+		if (!IPTools::ParseSubnet(subnet, subnetAddress, subnetMaskBits))
+		{
+			LOGERROR("GeoLite2: Could not parse Subnet %s\n", subnet.c_str());
+			return;
+		}
+		IPv4SubnetKeyType subnetKey = { subnetAddress, subnetMaskBits };
+
+		// Parse content
+		if (content == "Country")
+			ParseCountryBlocksLine(subnet, subnetKey, values);
+		else if (content == "City")
+			ParseCityBlocksLine(subnet, subnetKey, values);
+		else if (content == "ASN")
+			ParseASNBlocksLine(subnet, subnetKey, values);
+	};
+
+	return LoadCSVFile(filePath, m_BlocksHeader[content], readLine);
+}
+
+/**
+ * This function is also used to parse the first columns of the City Blocks file.
+ */
+void GeoLite2::ParseCountryBlocksLine(const std::string& UNUSED(subnet), const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values)
+{
+	if (values.size() < 6)
+		return;
+
+	const std::string& geonameID = values.at(1);
+	const std::string& registeredGeonameID = values.at(2);
+	const std::string& representedGeonameID = values.at(3);
+	const bool isAnonymous = values.at(4) == "1";
+	const bool isSatellite = values.at(5) == "1";
+
+	if (geonameID.empty())
+		return;
+
+	// Parse geonameID
+	const u32 geonameIDNum = static_cast<u32>(std::stoul(
+		geonameID.length() ? geonameID :
+		representedGeonameID.length() ? representedGeonameID :
+		registeredGeonameID));
+
+	// Store the data
+	m_Blocks_IPv4_GeoID[subnetKey] = geonameIDNum;
+
+	if (isSatellite)
+		m_Blocks_IPv4_Satellite.insert(subnetKey);
+
+	if (isAnonymous)
+		m_Blocks_IPv4_Anonymous.insert(subnetKey);
+}
+
+void GeoLite2::ParseCityBlocksLine(const std::string& subnet, const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values)
+{
+	ParseCountryBlocksLine(subnet, subnetKey, values);
+
+	// This can happen if the accuracy radius is empty
+	if (values.size() < 10)
+		return;
+
+	//const std::string& postal_code = values.at(6);
+	const std::string& latitude = values.at(7);
+	const std::string& longitude = values.at(8);
+	const std::string& accuracy_radius = values.at(9);
+
+	try
+	{
+		m_Blocks_IPv4_GeoCoordinates[subnetKey] = {
+			std::stof(latitude),
+			std::stof(longitude),
+			static_cast<u16>(std::stoul(accuracy_radius))
+		};
+	}
+	catch (...)
+	{
+		LOGERROR("Could not parse City Block data of %s", subnet.c_str());
+	}
+}
+
+void GeoLite2::ParseASNBlocksLine(const std::string& UNUSED(subnet), const IPv4SubnetKeyType& subnetKey, const std::vector<std::string>& values)
+{
+	if (values.size() < 3)
+		return;
+
+	const std::string& autonomousSystemNumber = values.at(1);
+	const std::string& autonomousSystemOrganization = values.at(2);
+
+	const u32 autonomousSystemNumberNum = static_cast<u32>(std::stoul(autonomousSystemNumber));
+
+	m_Blocks_IPv4_AutonomousSystemNumber[subnetKey] = autonomousSystemNumberNum;
+	m_Blocks_IPv4_AutonomousSystemOrganization[autonomousSystemNumberNum] = autonomousSystemOrganization;
+}
+
+/**
+ * Load
+ *   GeoLite2-City-Locations-en.csv or
+ *   GeoLite2-Country-Locations-en.csv or...
+ *
+ * The filesize can exceed 10MB.
+ *
+ * Example Country:
+ *   geoname_id,locale_code,continent_code,continent_name,country_iso_code,country_name,is_in_european_union
+ *   2264397,en,EU,Europe,PT,Portugal,1
+ *
+ *  Example City:
+ *   geoname_id,locale_code,continent_code,continent_name,country_iso_code,country_name,subdivision_1_iso_code,subdivision_1_name,subdivision_2_iso_code,subdivision_2_name,city_name,metro_code,time_zone,is_in_european_union
+ *   11696023,en,NA,"North America",CA,Canada,QC,Quebec,,,Sainte-Claire,,America/Toronto,0
+ */
+bool GeoLite2::LoadLocations(const std::string& content)
+{
+	// TODO: I suppose the language tag should be an argument provided elsewhere
+	std::vector<std::string> IETFLanguageTags = { m_IETFLanguageTag, "en" };
+
+	for (const std::string& IETFLanguageTag : IETFLanguageTags)
+	{
+		VfsPath filePath(m_Path / ("GeoLite2-" + content + "-Locations-" + IETFLanguageTag + ".csv"));
+
+		std::function<void(const std::vector<std::string>& values)> readLine = [this, content](const std::vector<std::string>& values)
+		{
+			if (values.size() < 1)
+				return;
+
+			const std::string& geonameID = values.at(0);
+			const u32 geonameIDNum = static_cast<u32>(std::stoul(geonameID));
+
+			if (content == "City")
+				ParseCityLocationsLine(geonameID, geonameIDNum, values);
+			else if (content == "Country")
+				ParseCountryLocationsLine(geonameID, geonameIDNum, values);
+		};
+
+		if (LoadCSVFile(filePath, m_LocationsHeader[content], readLine))
+			return true;
+	}
+
+	return false;
+}
+
+void GeoLite2::ParseCountryLocationsLine(const std::string& UNUSED(geonameID), const u32& geonameIDNum, const std::vector<std::string>& values)
+{
+	if (values.size() < 7)
+		return;
+
+	// Notice ICU could be used for country and continent names, but not for city names, so it would be inconsistent to do so.
+
+	// const std::string& localeCode = values.at(1);
+	// const std::string& continentCode = values.at(2);
+	const std::string& continentName = values.at(3);
+	const std::string& countryCode = values.at(4);
+	const std::string& countryName = values.at(5);
+	//const bool isInEuropeanUnion = values.at(6) == "1";
+
+	if (m_CountryLocations_CountryCodes.count(geonameIDNum) == 0)
+	{
+		m_CountryLocations_CountryCodes[geonameIDNum] = countryCode;
+		m_CountryLocations_CountryData[countryCode] = { continentName, countryName };
+	}
+}
+
+void GeoLite2::ParseCityLocationsLine(const std::string& geonameID, const u32& geonameIDNum, const std::vector<std::string>& values)
+{
+	if (values.size() < 14)
+		return;
+
+	ParseCountryLocationsLine(geonameID, geonameIDNum, values);
+
+	//const std::string& subdivision1Code = values.at(6);
+	//const std::string& subdivision1Name = values.at(7);
+	//const std::string& subdivision2Code = values.at(8);
+	//const std::string& subdivision2Name = values.at(9);
+	const std::string& cityName = values.at(10);
+	//const std::string& metroCode = values.at(11);
+	const std::string& timeZone = values.at(12);
+	//const bool isInEuropeanUnion = values.at(13) == "1";
+
+	// TODO: This duplicates a bit per city entry!
+	m_CityLocations[geonameIDNum] = { cityName, timeZone };
+}
+
+/**
+ * Loads the given GeoLite2 csv file as a map from the first value to the rest of the values.
+ */
+bool GeoLite2::LoadCSVFile(const VfsPath& filePath, const std::string& expectedHeader, std::function<void(const std::vector<std::string>&)>& lineRead)
+{
+	CVFSFile file;
+	// TODO: VfsFileExists needed?
+	if (!VfsFileExists(filePath) || file.Load(g_VFS, filePath) != PSRETURN_OK)
+		return false;
+
+	debug_printf("Loading %s", filePath.string8().c_str());
+	std::time_t started = std::time(nullptr);
+
+	std::stringstream sstream(file.DecodeUTF8());
+
+	// Read header
+	std::string header;
+	std::getline(sstream, header);
+
+	if (header != expectedHeader)
+	{
+		debug_printf("\n");
+		LOGERROR("Unexpected GeoLite2 csv header!");
+	}
+
+	// Notice that:
+	// 1. The comma separated values can be encapsulated in quotes if the word contains a comma
+	// 2. Quotes in comma separated values are escaped with a quote character, for example the city Kup""yans'k:
+	// 703656,en,EU,Europe,UA,Ukraine,63,"Kharkivs'ka Oblast'",,,"Kup""yans'k",,Europe/Kiev,0
+	std::string line;
+	while (std::getline(sstream, line))
+	{
+		std::vector<std::string> values;
+		{
+			std::stringstream valuesStream(line);
+			while (!valuesStream.eof())
+			{
+				const bool quoted = valuesStream.peek() == '"';
+				if (quoted)
+				{
+					valuesStream.ignore(1);
+
+					std::string value;
+					std::string word;
+					while(std::getline(valuesStream, word, '"'))
+					{
+						value += word;
+
+						if (valuesStream.peek() == '"')
+							// Remove quote escape character
+							valuesStream.ignore(1);
+						else
+							break;
+
+					}
+					values.push_back(value);
+				}
+				else
+				{
+					std::string value;
+					if (std::getline(valuesStream, value, ','))
+						values.push_back(value);
+				}
+
+				if (quoted)
+				{
+					char comma = 0;
+					valuesStream >> comma;
+					if (comma != ',' && comma != 0)
+					{
+						debug_printf("\n");
+						LOGERROR("CSV: Unterminated quoted comma-separated value in line %s!", line.c_str());
+					}
+				}
+			}
+		}
+		lineRead(values);
+	}
+
+	debug_printf(", took %lds.\n", std::time(nullptr) - started);
+	return true;
+}
+
+/**
+ * Returns the data of the given IP address from both Blocks and Location files.
+ */
+JS::Value GeoLite2::GetIPv4Data(const ScriptInterface& scriptInterface, u32 ipAddress)
+{
+	JSContext* cx = scriptInterface.GetContext();
+	JSAutoRequest rq(cx);
+	JS::RootedValue returnValue(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
+
+	bool foundBlock = false;
+	for (const std::pair<IPv4SubnetKeyType, u32>& block : m_Blocks_IPv4_GeoID)
+	{
+		const IPv4SubnetKeyType& subnetKey = block.first;
+		const u32& geonameIDNum = block.second;
+
+		if (!IPTools::IsIpV4PartOfSubnet(ipAddress, subnetKey.first, subnetKey.second))
+			continue;
+
+		// Blocks data
+		scriptInterface.SetProperty(returnValue, "isAnonymous", m_Blocks_IPv4_Anonymous.count(subnetKey) != 0);
+		scriptInterface.SetProperty(returnValue, "isSatellite", m_Blocks_IPv4_Satellite.count(subnetKey) != 0);
+
+		if (m_Blocks_IPv4_GeoCoordinates.count(subnetKey) != 0)
+		{
+			scriptInterface.SetProperty(returnValue, "longitude", std::get<0>(m_Blocks_IPv4_GeoCoordinates.at(subnetKey)));
+			scriptInterface.SetProperty(returnValue, "latitude", std::get<1>(m_Blocks_IPv4_GeoCoordinates.at(subnetKey)));
+			scriptInterface.SetProperty(returnValue, "accuracyRadius", std::get<2>(m_Blocks_IPv4_GeoCoordinates.at(subnetKey)));
+		}
+
+		// Locations data
+		if (m_CountryLocations_CountryCodes.count(geonameIDNum) != 0)
+		{
+			const std::string& countryCode = m_CountryLocations_CountryCodes.at(geonameIDNum);
+			const std::pair<std::string, std::string>& countryData = m_CountryLocations_CountryData.at(countryCode);
+
+			scriptInterface.SetProperty(returnValue, "countryCode", wstring_from_utf8(countryCode));
+			scriptInterface.SetProperty(returnValue, "continentName", wstring_from_utf8(countryData.first));
+			scriptInterface.SetProperty(returnValue, "countryName", wstring_from_utf8(countryData.second));
+		}
+
+		if (m_CityLocations.count(geonameIDNum) != 0)
+		{
+			scriptInterface.SetProperty(returnValue, "cityName", wstring_from_utf8(m_CityLocations.at(geonameIDNum).at(0)));
+			scriptInterface.SetProperty(returnValue, "timeZone", wstring_from_utf8(m_CityLocations.at(geonameIDNum).at(1)));
+		}
+
+		foundBlock = true;
+		break;
+	}
+
+	if (!foundBlock)
+	{
+		return JS::UndefinedValue();
+	}
+
+	// ASN data
+	// Notice the different csv files use different subnets
+	for (const std::pair<IPv4SubnetKeyType, u32>& autonomousSystem : m_Blocks_IPv4_AutonomousSystemNumber)
+	{
+		const IPv4SubnetKeyType& subnetKey = autonomousSystem.first;
+		const u32& autonomousSystemNumberNum = autonomousSystem.second;
+
+		if (IPTools::IsIpV4PartOfSubnet(ipAddress, subnetKey.first, subnetKey.second) ||
+		    m_Blocks_IPv4_AutonomousSystemNumber.count(subnetKey) == 0)
+		{
+			scriptInterface.SetProperty(returnValue, "autonomousSystemOrganization", m_Blocks_IPv4_AutonomousSystemOrganization.at(autonomousSystemNumberNum));
+			break;
+		}
+	}
+
+	return returnValue;
+}
Index: source/network/IPTools.h
===================================================================
--- /dev/null
+++ source/network/IPTools.h
@@ -0,0 +1,31 @@
+/* Copyright (C) 2019 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 IPTOOLS_H
+#define IPTOOLS_H
+
+#include <string>
+
+namespace IPTools
+{
+	bool ParseIPv4Address(const std::string& ipAddress, u32& ipAddressNum);
+	bool ParseSubnet(const std::string& subnetString, u32& subnetAddress, u8& subnetMaskBits);
+
+	bool IsIpV4PartOfSubnet(u32 ipAddress, u32 subnetAddress, int subnetMaskBits);
+}
+
+#endif // IPTOOLS_H
Index: source/network/IPTools.cpp
===================================================================
--- /dev/null
+++ source/network/IPTools.cpp
@@ -0,0 +1,67 @@
+/* Copyright (C) 2019 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/>.
+ */
+
+#include "precompiled.h"
+
+#include "IPTools.h"
+
+#include <arpa/inet.h>
+#include <string>
+
+// TODO: implement banmasks
+
+/**
+ * Parses an IPv4 address, such as "223.252.161.128" to an u32 representation in hostbyte order (useful for bitmask matching).
+ */
+bool IPTools::ParseIPv4Address(const std::string& ipAddress, u32& ipAddressNum)
+{
+	// Returns in network byte order, big endianness
+	// TODO: This doesn't exist on all platforms
+	if (inet_pton(AF_INET, ipAddress.c_str(), &ipAddressNum) != 1)
+		return false;
+
+	// Convert to host byte order (little endianness)
+	ipAddressNum = ntohl(ipAddressNum);
+	return true;
+}
+
+/**
+ * Parses CIDR notation, for example "223.252.161.128/25".
+ */
+bool IPTools::ParseSubnet(const std::string& subnet, u32& subnetAddress, u8& subnetMaskBits)
+{
+	std::istringstream subnetStream(subnet);
+	std::string subnetAddressString;
+	std::getline(subnetStream, subnetAddressString, '/');
+
+	if (!ParseIPv4Address(subnetAddressString, subnetAddress))
+		return false;
+
+	std::string subnetMaskBitsString;
+	std::getline(subnetStream, subnetMaskBitsString);
+	subnetMaskBits = static_cast<u8>(std::stoi(subnetMaskBitsString));
+
+	return true;
+}
+
+/**
+ * All values in hostbyte order (little endianness)
+ */
+bool IPTools::IsIpV4PartOfSubnet(u32 ipAddress, u32 subnetAddress, int subnetMaskBits)
+{
+	return ((0xFFFFFFFF << (32 - subnetMaskBits)) & ipAddress) == subnetAddress;
+}
Index: source/network/NetClient.h
===================================================================
--- source/network/NetClient.h
+++ source/network/NetClient.h
@@ -149,6 +149,8 @@
 	 */
 	void GuiPoll(JS::MutableHandleValue);
 
+	JS::Value GetClientPerformance();
+
 	/**
 	 * Add a message to the queue, to be read by GuiPoll.
 	 * The script value must be in the GetScriptInterface() JS context.
@@ -243,7 +245,6 @@
 	static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
 	static bool OnRejoined(void* context, CFsmEvent* event);
 	static bool OnKicked(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);
 	static bool OnClientPaused(void* context, CFsmEvent* event);
@@ -284,6 +285,9 @@
 	/// Latest copy of player assignments heard from the server
 	PlayerAssignmentMap m_PlayerAssignments;
 
+	// Latest copy of roundtrip time and lost packets
+	std::map<std::string, std::tuple<u32, u32, double>> m_ClientPerformance;
+
 	/// Globally unique identifier to distinguish users beyond the lifetime of a single network session
 	CStr m_GUID;
 
Index: source/network/NetClient.cpp
===================================================================
--- source/network/NetClient.cpp
+++ source/network/NetClient.cpp
@@ -36,6 +36,8 @@
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 
+#include <map>
+
 CNetClient *g_NetClient = NULL;
 
 /**
@@ -99,7 +101,6 @@
 	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_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);
 	AddTransition(NCS_PREGAME, (uint)NMT_JOIN_SYNC_START, NCS_JOIN_SYNCING, (void*)&OnJoinSyncStart, context);
@@ -108,7 +109,6 @@
 	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_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);
 	AddTransition(NCS_JOIN_SYNCING, (uint)NMT_SIMULATION_COMMAND, NCS_JOIN_SYNCING, (void*)&OnInGame, context);
@@ -119,14 +119,12 @@
 	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_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);
 	AddTransition(NCS_LOADING, (uint)NMT_LOADED_GAME, NCS_INGAME, (void*)&OnLoadedGame, context);
 
 	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_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);
 	AddTransition(NCS_INGAME, (uint)NMT_CLIENT_PAUSED, NCS_INGAME, (void*)&OnClientPaused, context);
@@ -201,37 +199,13 @@
 
 void CNetClient::CheckServerConnection()
 {
-	// Trigger local warnings if the connection to the server is bad.
-	// At most once per second.
 	std::time_t now = std::time(nullptr);
 	if (now <= m_LastConnectionCheck)
 		return;
 
 	m_LastConnectionCheck = now;
 
-	JSContext* cx = GetScriptInterface().GetContext();
-	JSAutoRequest rq(cx);
-
-	// Report if we are losing the connection to the server
-	u32 lastReceived = m_Session->GetLastReceivedTime();
-	if (lastReceived > NETWORK_WARNING_TIMEOUT)
-	{
-		JS::RootedValue msg(cx);
-		GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-timeout' })", &msg);
-		GetScriptInterface().SetProperty(msg, "lastReceivedTime", lastReceived);
-		PushGuiMessage(msg);
-		return;
-	}
-
-	// Report if we have a bad ping to the server
-	u32 meanRTT = m_Session->GetMeanRTT();
-	if (meanRTT > DEFAULT_TURN_LENGTH_MP)
-	{
-		JS::RootedValue msg(cx);
-		GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'server-latency' })", &msg);
-		GetScriptInterface().SetProperty(msg, "meanRTT", meanRTT);
-		PushGuiMessage(msg);
-	}
+	m_ClientPerformance[m_GUID] = std::make_tuple(m_Session->GetMeanRTT(), m_Session->GetLastReceivedTime(), m_Session->GetPacketLossRatio());
 }
 
 void CNetClient::Flush()
@@ -663,10 +637,17 @@
 		assignment.m_PlayerID = message->m_Hosts[i].m_PlayerID;
 		assignment.m_Status = message->m_Hosts[i].m_Status;
 		newPlayerAssignments[message->m_Hosts[i].m_GUID] = assignment;
+
+		if (!client->m_ClientPerformance.count(message->m_Hosts[i].m_GUID))
+			client->m_ClientPerformance[message->m_Hosts[i].m_GUID] = std::make_tuple(0, 0, 0.d);
 	}
 
 	client->m_PlayerAssignments.swap(newPlayerAssignments);
 
+	for (std::map<std::string, std::tuple<u32, u32, double>>::iterator iter = client->m_ClientPerformance.begin(); iter != client->m_ClientPerformance.end(); ++iter)
+		if (!client->m_PlayerAssignments.count(iter->first))
+			client->m_ClientPerformance.erase(iter);
+
 	client->PostPlayerAssignmentsToScript();
 
 	return true;
@@ -769,27 +750,6 @@
 	return true;
 }
 
-bool CNetClient::OnClientTimeout(void *context, CFsmEvent* event)
-{
-	// Report the timeout of some other client
-
-	ENSURE(event->GetType() == (uint)NMT_CLIENT_TIMEOUT);
-
-	CNetClient* client = (CNetClient*)context;
-	JSContext* cx = client->GetScriptInterface().GetContext();
-	JSAutoRequest rq(cx);
-
-	CClientTimeoutMessage* message = (CClientTimeoutMessage*)event->GetParamRef();
-	JS::RootedValue msg(cx);
-
-	client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-timeout' })", &msg);
-	client->GetScriptInterface().SetProperty(msg, "guid", std::string(message->m_GUID));
-	client->GetScriptInterface().SetProperty(msg, "lastReceivedTime", message->m_LastReceivedTime);
-	client->PushGuiMessage(msg);
-
-	return true;
-}
-
 bool CNetClient::OnClientPerformance(void *context, CFsmEvent* event)
 {
 	// Performance statistics for one or multiple clients
@@ -802,18 +762,11 @@
 
 	CClientPerformanceMessage* message = (CClientPerformanceMessage*)event->GetParamRef();
 
-	// Display warnings for other clients with bad ping
-	for (size_t i = 0; i < message->m_Clients.size(); ++i)
-	{
-		if (message->m_Clients[i].m_MeanRTT < DEFAULT_TURN_LENGTH_MP || message->m_Clients[i].m_GUID == client->m_GUID)
-			continue;
-
-		JS::RootedValue msg(cx);
-		client->GetScriptInterface().Eval("({ 'type':'netwarn', 'warntype': 'client-latency' })", &msg);
-		client->GetScriptInterface().SetProperty(msg, "guid", message->m_Clients[i].m_GUID);
-		client->GetScriptInterface().SetProperty(msg, "meanRTT", message->m_Clients[i].m_MeanRTT);
-		client->PushGuiMessage(msg);
-	}
+	for (const CClientPerformanceMessage::S_m_Clients& mClient : message->m_Clients)
+		client->m_ClientPerformance[mClient.m_GUID] = std::make_tuple(
+			mClient.m_MeanRTT,
+			mClient.m_LastReceivedTime,
+			mClient.m_PacketLoss / PACKET_LOSS_SCALE);
 
 	return true;
 }
@@ -924,3 +877,22 @@
 
 	return true;
 }
+
+JS::Value CNetClient::GetClientPerformance()
+{
+	JSContext* cx = GetScriptInterface().GetContext();
+	JSAutoRequest rq(cx);
+
+	JS::RootedValue performanceVals(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
+
+	for (const std::pair<std::string, std::tuple<u32, u32, double>>& clientPerf : m_ClientPerformance)
+	{
+		JS::RootedValue performanceVal(cx, JS::ObjectValue(*JS_NewPlainObject(cx)));
+		GetScriptInterface().SetProperty(performanceVal, "meanRTT", std::get<0>(clientPerf.second));
+		GetScriptInterface().SetProperty(performanceVal, "lastReceivedTime", std::get<1>(clientPerf.second));
+		GetScriptInterface().SetProperty(performanceVal, "packetLoss", std::get<2>(clientPerf.second));
+		GetScriptInterface().SetProperty(performanceVals, clientPerf.first.c_str(), performanceVal);
+	}
+
+	return performanceVals;
+}
Index: source/network/NetMessage.cpp
===================================================================
--- source/network/NetMessage.cpp
+++ source/network/NetMessage.cpp
@@ -139,10 +139,6 @@
 		pNewMessage = new CKickedMessage;
 		break;
 
-	case NMT_CLIENT_TIMEOUT:
-		pNewMessage = new CClientTimeoutMessage;
-		break;
-
 	case NMT_CLIENT_PERFORMANCE:
 		pNewMessage = new CClientPerformanceMessage;
 		break;
Index: source/network/NetMessages.h
===================================================================
--- source/network/NetMessages.h
+++ source/network/NetMessages.h
@@ -68,7 +68,6 @@
 	NMT_REJOINED,
 	NMT_KICKED,
 
-	NMT_CLIENT_TIMEOUT,
 	NMT_CLIENT_PERFORMANCE,
 	NMT_CLIENTS_LOADING,
 	NMT_CLIENT_PAUSED,
@@ -185,15 +184,12 @@
 	NMT_FIELD_INT(m_Ban, u8, 1)
 END_NMT_CLASS()
 
-START_NMT_CLASS_(ClientTimeout, NMT_CLIENT_TIMEOUT)
-	NMT_FIELD(CStr, m_GUID)
-	NMT_FIELD_INT(m_LastReceivedTime, u32, 4)
-END_NMT_CLASS()
-
 START_NMT_CLASS_(ClientPerformance, NMT_CLIENT_PERFORMANCE)
 	NMT_START_ARRAY(m_Clients)
 		NMT_FIELD(CStr, m_GUID)
 		NMT_FIELD_INT(m_MeanRTT, u32, 4)
+		NMT_FIELD_INT(m_LastReceivedTime, u32, 4)
+		NMT_FIELD_INT(m_PacketLoss, u32, 4)
 	NMT_END_ARRAY()
 END_NMT_CLASS()
 
Index: source/network/NetServer.h
===================================================================
--- source/network/NetServer.h
+++ source/network/NetServer.h
@@ -141,6 +141,9 @@
 
 	bool UseLobbyAuth() const;
 
+	std::string GetClientIPAddress(const std::string& guid);
+	std::string GetHostname(const std::string& guid);
+
 	void OnLobbyAuth(const CStr& name, const CStr& token);
 
 	void SendHolePunchingMessage(const CStr& ip, u16 port);
@@ -184,6 +187,9 @@
 	 */
 	bool Broadcast(const CNetMessage* message, const std::vector<NetServerSessionState>& targetStates);
 
+	std::string GetClientIPAddress(const std::string& guid);
+	std::string GetHostname(const std::string& guid);
+
 private:
 	friend class CNetServer;
 	friend class CNetFileReceiveTask_ServerRejoin;
@@ -283,9 +289,9 @@
 	void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
 	/**
-	 * Send a network warning if the connection to a client is being lost or has bad latency.
+	 * Inform clients if the connection to a client is being lost or has bad latency.
 	 */
-	void CheckClientConnections();
+	void BroadcastClientPerformance();
 
 	void SendHolePunchingMessage(const CStr& ip, u16 port);
 
@@ -324,6 +330,11 @@
 	std::vector<CStrW> m_BannedPlayers;
 
 	/**
+	 * Caches hostname per GUID of connected players.
+	 */
+	//std::vector<std::string, std::string> g_HostNames;
+
+	/**
 	 * Holds the GUIDs of all currently paused players.
 	 */
 	std::vector<CStr> m_PausingPlayers;
Index: source/network/NetServer.cpp
===================================================================
--- source/network/NetServer.cpp
+++ source/network/NetServer.cpp
@@ -361,6 +361,24 @@
 	return ok;
 }
 
+std::string CNetServerWorker::GetClientIPAddress(const std::string& guid)
+{
+	for (CNetServerSession* session : m_Sessions)
+		if (session->GetGUID() == guid)
+			return session->GetIPAddressString();
+
+	return "";
+}
+
+std::string CNetServerWorker::GetHostname(const std::string& guid)
+{
+	for (CNetServerSession* session : m_Sessions)
+		if (session->GetGUID() == guid)
+			return session->GetHostname();
+
+	return "";
+}
+
 void* CNetServerWorker::RunThread(void* data)
 {
 	debug_SetThreadName("NetServer");
@@ -452,7 +470,7 @@
 	for (CNetServerSession* session : m_Sessions)
 		session->GetFileTransferer().Poll();
 
-	CheckClientConnections();
+	BroadcastClientPerformance();
 
 	// Process network events:
 
@@ -555,7 +573,7 @@
 	return true;
 }
 
-void CNetServerWorker::CheckClientConnections()
+void CNetServerWorker::BroadcastClientPerformance()
 {
 	// Send messages at most once per second
 	std::time_t now = std::time(nullptr);
@@ -564,48 +582,32 @@
 
 	m_LastConnectionCheck = now;
 
-	for (size_t i = 0; i < m_Sessions.size(); ++i)
+	for (CNetServerSession* addresseeSession : m_Sessions)
 	{
-		u32 lastReceived = m_Sessions[i]->GetLastReceivedTime();
-		u32 meanRTT = m_Sessions[i]->GetMeanRTT();
+		// Skip disconnecting clients and clients in the loading screen
+		if (addresseeSession->GetLastReceivedTime() >= 3000 ||
+		    addresseeSession->GetCurrState() < NSS_PREGAME ||
+		    addresseeSession->GetCurrState() == FSM_INVALID_STATE ||
+			(addresseeSession->GetCurrState() == NSS_PREGAME && m_State == SERVER_STATE_LOADING))
+			continue;
 
-		CNetMessage* message = nullptr;
+		CClientPerformanceMessage msg;
 
-		// Report if we didn't hear from the client since few seconds
-		if (lastReceived > NETWORK_WARNING_TIMEOUT)
+		for (CNetServerSession* measuredSession : m_Sessions)
 		{
-			CClientTimeoutMessage* msg = new CClientTimeoutMessage();
-			msg->m_GUID = m_Sessions[i]->GetGUID();
-			msg->m_LastReceivedTime = lastReceived;
-			message = msg;
-		}
-		// Report if the client has bad ping
-		else if (meanRTT > DEFAULT_TURN_LENGTH_MP)
-		{
-			CClientPerformanceMessage* msg = new CClientPerformanceMessage();
+			// Inform clients about every connection except their own (since they measure that themself)
+			if (measuredSession->GetGUID() == addresseeSession->GetGUID())
+				continue;
+
 			CClientPerformanceMessage::S_m_Clients client;
-			client.m_GUID = m_Sessions[i]->GetGUID();
-			client.m_MeanRTT = meanRTT;
-			msg->m_Clients.push_back(client);
-			message = msg;
+			client.m_GUID = measuredSession->GetGUID();
+			client.m_MeanRTT = measuredSession->GetMeanRTT();
+			client.m_LastReceivedTime = measuredSession->GetLastReceivedTime();
+			client.m_PacketLoss = measuredSession->GetPacketLoss();
+			msg.m_Clients.push_back(client);
 		}
 
-		// Send to all clients except the affected one
-		// (since that will show the locally triggered warning instead).
-		// Also send it to clients that finished the loading screen while
-		// the game is still waiting for other clients to finish the loading screen.
-		if (message)
-			for (size_t j = 0; j < m_Sessions.size(); ++j)
-			{
-				if (i != j && (
-				    (m_Sessions[j]->GetCurrState() == NSS_PREGAME && m_State == SERVER_STATE_PREGAME) ||
-				    m_Sessions[j]->GetCurrState() == NSS_INGAME))
-				{
-					m_Sessions[j]->SendMessage(message);
-				}
-			}
-
-		SAFE_DELETE(message);
+		addresseeSession->SendMessage(&msg);
 	}
 }
 
@@ -686,6 +688,8 @@
 		return false;
 	}
 
+	// TODO: check for banned hostnames
+
 	CSrvHandshakeMessage handshake;
 	handshake.m_Magic = PS_PROTOCOL_MAGIC;
 	handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
@@ -1590,6 +1594,19 @@
 	return m_Worker->SetupConnection(port);
 }
 
+std::string CNetServer::GetClientIPAddress(const std::string& guid)
+{
+	// The server should broadcast the countries, IPs and hostnames in an admin packet each time a player joins/disconnects
+	CScopeLock lock(m_Worker->m_WorkerMutex);
+	return m_Worker->GetClientIPAddress(guid);
+}
+
+std::string CNetServer::GetHostname(const std::string& guid)
+{
+	CScopeLock lock(m_Worker->m_WorkerMutex);
+	return m_Worker->GetHostname(guid);
+}
+
 void CNetServer::StartGame()
 {
 	CScopeLock lock(m_Worker->m_WorkerMutex);
Index: source/network/NetSession.h
===================================================================
--- source/network/NetSession.h
+++ source/network/NetSession.h
@@ -25,14 +25,14 @@
 #include "scriptinterface/ScriptVal.h"
 
 /**
- * Report the peer if we didn't receive a packet after this time (milliseconds).
+ *  Maximum timeout of the local client of the host (milliseconds).
  */
-extern const u32 NETWORK_WARNING_TIMEOUT;
+extern const u32 MAXIMUM_HOST_TIMEOUT;
 
 /**
- *  Maximum timeout of the local client of the host (milliseconds).
+ * Denominator of the packet loss ratio, whereas the numerator is sent as u32.
  */
-extern const u32 MAXIMUM_HOST_TIMEOUT;
+extern const double PACKET_LOSS_SCALE;
 
 class CNetClient;
 class CNetServerWorker;
@@ -106,6 +106,11 @@
 	u32 GetMeanRTT() const;
 
 	/**
+	 * Average ratio of packets lost.
+	 */
+	double GetPacketLossRatio() const;
+
+	/**
 	 * Allows increasing the timeout to prevent drops during an expensive operation,
 	 * and decreasing it back to normal afterwards.
 	 */
@@ -153,6 +158,8 @@
 	void SetHostID(u32 id) { m_HostID = id; }
 
 	u32 GetIPAddress() const;
+	std::string GetIPAddressString() const;
+	std::string GetHostname() const;
 
 	/**
 	 * Whether this client is running in the same process as the server.
@@ -170,6 +177,11 @@
 	u32 GetMeanRTT() const;
 
 	/**
+	 * Average ratio of packets lost with regards to ENET_PEER_PACKET_LOSS_SCALE. Indicates connection quality.
+	 */
+	u32 GetPacketLoss() const;
+
+	/**
 	 * Sends a disconnection notification to the client,
 	 * and sends a NMT_CONNECTION_LOST message to the session FSM.
 	 * The server will receive a disconnection notification after a while.
@@ -213,6 +225,9 @@
 	CStrW m_UserName;
 	u32 m_HostID;
 
+	// Cache
+	CStr m_Hostname;
+
 	bool m_IsLocalClient;
 };
 
Index: source/network/NetSession.cpp
===================================================================
--- source/network/NetSession.cpp
+++ source/network/NetSession.cpp
@@ -27,10 +27,11 @@
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
-const u32 NETWORK_WARNING_TIMEOUT = 2000;
-
 const u32 MAXIMUM_HOST_TIMEOUT = std::numeric_limits<u32>::max();
 
+const double PACKET_LOSS_SCALE = (1 << 16);
+const double PACKET_LOSS_SCALE_FACTOR = PACKET_LOSS_SCALE / ENET_PEER_PACKET_LOSS_SCALE;
+
 static const int CHANNEL_COUNT = 1;
 
 // Only disable long timeouts after a packet from the remote enet peer has been processed.
@@ -149,6 +150,7 @@
 			// Report the server address
 			char hostname[256] = "(error)";
 			enet_address_get_host_ip(&event.peer->address, hostname, ARRAY_SIZE(hostname));
+
 			LOGMESSAGE("Net client: Connected to %s:%u", hostname, (unsigned int)event.peer->address.port);
 
 			m_Client.HandleConnect();
@@ -221,6 +223,14 @@
 	return m_Server->roundTripTime;
 }
 
+double CNetClientSession::GetPacketLossRatio() const
+{
+	if (!m_Server)
+		return 0;
+
+	return (double) m_Server->packetLoss / (double) ENET_PEER_PACKET_LOSS_SCALE;
+}
+
 void CNetClientSession::SetLongTimeout(bool enabled)
 {
 	SetEnetLongTimeout(m_Server, m_IsLocalClient, enabled);
@@ -229,6 +239,9 @@
 CNetServerSession::CNetServerSession(CNetServerWorker& server, ENetPeer* peer) :
 	m_Server(server), m_FileTransferer(this), m_Peer(peer), m_IsLocalClient(false), m_HostID(0), m_GUID(), m_UserName()
 {
+	char hostname[256] = "(error)";
+	if (enet_address_get_host(&peer->address, hostname, ARRAY_SIZE(hostname)) == 0)
+		m_Hostname = hostname;
 }
 
 u32 CNetServerSession::GetIPAddress() const
@@ -236,6 +249,22 @@
 	return m_Peer->address.host;
 }
 
+std::string CNetServerSession::GetIPAddressString() const
+{
+	char ipAddress[256];
+	ipAddress[255] = '\0';
+
+	if (enet_address_get_host_ip(&m_Peer->address, ipAddress, sizeof ipAddress) != 0)
+		return std::string();
+
+	return ipAddress;
+}
+
+std::string CNetServerSession::GetHostname() const
+{
+	return m_Hostname;
+}
+
 u32 CNetServerSession::GetLastReceivedTime() const
 {
 	if (!m_Peer)
@@ -252,6 +281,14 @@
 	return m_Peer->roundTripTime;
 }
 
+u32 CNetServerSession::GetPacketLoss() const
+{
+	if (!m_Peer)
+		return 0;
+
+	return (double) m_Peer->packetLoss * PACKET_LOSS_SCALE_FACTOR;
+}
+
 void CNetServerSession::Disconnect(u32 reason)
 {
 	Update((uint)NMT_CONNECTION_LOST, NULL);
Index: source/network/scripting/JSInterface_GeoLite2.h
===================================================================
--- /dev/null
+++ source/network/scripting/JSInterface_GeoLite2.h
@@ -0,0 +1,34 @@
+/* Copyright (C) 2019 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 INCLUDED_JSI_GEOLITE2
+#define INCLUDED_JSI_GEOLITE2
+
+#include "network/GeoLite2.h"
+#include "scriptinterface/ScriptInterface.h"
+
+#include <string>
+#include <vector>
+
+namespace JSI_GeoLite2
+{
+	JS::Value GetGeoLite2(ScriptInterface::CxPrivate* pCxPrivate, const std::string& ipAddress);
+
+	void RegisterScriptFunctions(const ScriptInterface& scriptInterface);
+}
+
+#endif // INCLUDED_JSI_GEOLITE2
Index: source/network/scripting/JSInterface_GeoLite2.cpp
===================================================================
--- /dev/null
+++ source/network/scripting/JSInterface_GeoLite2.cpp
@@ -0,0 +1,50 @@
+/* Copyright (C) 2019 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/>.
+ */
+
+#include "precompiled.h"
+
+#include "JSInterface_GeoLite2.h"
+
+#include "network/GeoLite2.h"
+#include "network/IPTools.h"
+
+#include <string>
+#include <vector>
+
+// Notice that the GeoLite2 files could be used entirely without the JSInterface GeoLite2 namespace; by using JSI_VFS::ReadFileLines.
+// However the below functions are introduced to provide (1) caching of the 10mb database and (2) using inet.h instead of reinventing these methods in JS.
+
+JS::Value JSI_GeoLite2::GetGeoLite2(ScriptInterface::CxPrivate* pCxPrivate, const std::string& ipAddress)
+{
+	if (!g_GeoLite2)
+		return JS::UndefinedValue();
+
+	{
+		u32 ipAddressNum;
+		if (IPTools::ParseIPv4Address(ipAddress, ipAddressNum))
+			return g_GeoLite2->GetIPv4Data(*(pCxPrivate->pScriptInterface), ipAddressNum);
+	}
+
+	// TODO: Support IPv6
+
+	return JS::UndefinedValue();
+}
+
+void JSI_GeoLite2::RegisterScriptFunctions(const ScriptInterface& scriptInterface)
+{
+	scriptInterface.RegisterFunction<JS::Value, std::string, &GetGeoLite2>("GetGeoLite2");
+}
Index: source/network/scripting/JSInterface_Network.h
===================================================================
--- source/network/scripting/JSInterface_Network.h
+++ source/network/scripting/JSInterface_Network.h
@@ -34,13 +34,18 @@
 	JS::Value FindStunEndpoint(ScriptInterface::CxPrivate* pCxPrivate, int port);
 	void DisconnectNetworkGame(ScriptInterface::CxPrivate* pCxPrivate);
 	JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate);
+	JS::Value GetNetworkClientPerformance(ScriptInterface::CxPrivate* pCxPrivate);
 	CStr GetPlayerGUID(ScriptInterface::CxPrivate* pCxPrivate);
 	void KickPlayer(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& playerName, bool ban);
 	void AssignNetworkPlayer(ScriptInterface::CxPrivate* pCxPrivate, int playerID, const CStr& guid);
 	void ClearAllPlayerReady (ScriptInterface::CxPrivate* pCxPrivate);
 	void SendNetworkChat(ScriptInterface::CxPrivate* pCxPrivate, const CStrW& message);
 	void SendNetworkReady(ScriptInterface::CxPrivate* pCxPrivate, int message);
+	u32 GetTurnLength(ScriptInterface::CxPrivate* pCxPrivate);
 	void SetTurnLength(ScriptInterface::CxPrivate* pCxPrivate, int length);
+	std::string GetClientIPAddress(ScriptInterface::CxPrivate* pCxPrivate, const std::string& guid);
+	std::string LookupClientHostname(ScriptInterface::CxPrivate* pCxPrivate, const std::string& guid);
+	u32 IPv4ToNumber(ScriptInterface::CxPrivate* pCxPrivate, const std::string& ipAddress);
 
 	void RegisterScriptFunctions(const ScriptInterface& scriptInterface);
 }
Index: source/network/scripting/JSInterface_Network.cpp
===================================================================
--- source/network/scripting/JSInterface_Network.cpp
+++ source/network/scripting/JSInterface_Network.cpp
@@ -23,12 +23,14 @@
 #include "lib/external_libraries/libsdl.h"
 #include "lib/types.h"
 #include "lobby/IXmppClient.h"
+#include "network/IPTools.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
 #include "network/NetServer.h"
 #include "network/StunClient.h"
 #include "ps/CLogger.h"
 #include "ps/Game.h"
+#include "simulation2/system/TurnManager.h"
 #include "scriptinterface/ScriptInterface.h"
 
 u16 JSI_Network::GetDefaultPort(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
@@ -163,6 +165,18 @@
 	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(g_NetClient->GetScriptInterface(), pollNet);
 }
 
+JS::Value JSI_Network::GetNetworkClientPerformance(ScriptInterface::CxPrivate* pCxPrivate)
+{
+	if (!g_NetClient)
+		return JS::UndefinedValue();
+// TODO: Too many questionmarks in the dialog
+	// Convert from net client context to GUI script context
+	JSContext* cxNet = g_NetClient->GetScriptInterface().GetContext();
+	JSAutoRequest rqNet(cxNet);
+	JS::RootedValue pollNet(cxNet, g_NetClient->GetClientPerformance());
+	return pCxPrivate->pScriptInterface->CloneValueFromOtherContext(g_NetClient->GetScriptInterface(), pollNet);
+}
+
 void JSI_Network::SetNetworkGameAttributes(ScriptInterface::CxPrivate* pCxPrivate, JS::HandleValue attribs1)
 {
 	ENSURE(g_NetClient);
@@ -216,6 +230,11 @@
 	g_NetClient->SendStartGameMessage();
 }
 
+u32 JSI_Network::GetTurnLength(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+	return DEFAULT_TURN_LENGTH_MP;
+}
+
 void JSI_Network::SetTurnLength(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int length)
 {
 	if (g_NetServer)
@@ -224,6 +243,32 @@
 		LOGERROR("Only network host can change turn length");
 }
 
+std::string JSI_Network::GetClientIPAddress(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& guid)
+{
+	if (!g_NetServer)
+		return std::string();
+
+	return g_NetServer->GetClientIPAddress(guid);
+}
+
+std::string JSI_Network::LookupClientHostname(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& guid)
+{
+	if (!g_NetServer)
+		return std::string();
+
+	return g_NetServer->GetHostname(guid);
+}
+
+u32 JSI_Network::IPv4ToNumber(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), const std::string& ipAddress)
+{
+	u32 ipAddressNum = 0;
+
+	if (!IPTools::ParseIPv4Address(ipAddress, ipAddressNum))
+		return 0;
+
+	return ipAddressNum;
+}
+
 void JSI_Network::RegisterScriptFunctions(const ScriptInterface& scriptInterface)
 {
 	scriptInterface.RegisterFunction<u16, &GetDefaultPort>("GetDefaultPort");
@@ -235,6 +280,7 @@
 	scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
 	scriptInterface.RegisterFunction<CStr, &GetPlayerGUID>("GetPlayerGUID");
 	scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
+	scriptInterface.RegisterFunction<JS::Value, &GetNetworkClientPerformance>("GetNetworkClientPerformance");
 	scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
 	scriptInterface.RegisterFunction<void, int, CStr, &AssignNetworkPlayer>("AssignNetworkPlayer");
 	scriptInterface.RegisterFunction<void, CStrW, bool, &KickPlayer>("KickPlayer");
@@ -242,5 +288,9 @@
 	scriptInterface.RegisterFunction<void, int, &SendNetworkReady>("SendNetworkReady");
 	scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
 	scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
+	scriptInterface.RegisterFunction<u32, &GetTurnLength>("GetTurnLength");
 	scriptInterface.RegisterFunction<void, int, &SetTurnLength>("SetTurnLength");
+	scriptInterface.RegisterFunction<std::string, std::string, &GetClientIPAddress>("GetClientIPAddress");
+	scriptInterface.RegisterFunction<u32, std::string, &IPv4ToNumber>("IPv4ToNumber");
+	scriptInterface.RegisterFunction<std::string, std::string, &LookupClientHostname>("LookupClientHostname");
 }
Index: source/ps/GameSetup/GameSetup.cpp
===================================================================
--- source/ps/GameSetup/GameSetup.cpp
+++ source/ps/GameSetup/GameSetup.cpp
@@ -40,6 +40,7 @@
 #include "gui/scripting/ScriptFunctions.h"
 #include "i18n/L10n.h"
 #include "maths/MathUtil.h"
+#include "network/GeoLite2.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetMessage.h"
@@ -704,8 +705,8 @@
 
 	EndGame();
 
+	SAFE_DELETE(g_GeoLite2);
 	SAFE_DELETE(g_XmppClient);
-
 	SAFE_DELETE(g_ModIo);
 
 	ShutdownPs();
@@ -968,6 +969,13 @@
 
 	new L10n;
 
+	if (GeoLite2::IsEnabled())
+	{
+		// TODO: this ain't proper format
+		std::string language = g_L10n.GetCurrentLocale().getCountry();
+		g_GeoLite2 = new GeoLite2(language);
+	}
+
 	// Optionally start profiler HTTP output automatically
 	// (By default it's only enabled by a hotkey, for security/performance)
 	bool profilerHTTPEnable = false;