Ticket #3241: t3241_kick_v4.1.patch

binaries/data/mods/public/gui/common/network.js

@@ -5 +5 @@
     {
     case 0: return translate("Unknown reason");
     case 1: return translate("Unexpected shutdown");
     case 2: return translate("Incorrect network protocol version");
     case 3: return translate("Game has already started");
+    case 4: return translate("You have been kicked from the match.");
+    case 5: return translate("You have been banned from the match.");
     default: return sprintf(translate("\\[Invalid value %(id)s]"), { id: id });
     }
 }
 
 function reportDisconnect(reason)

binaries/data/mods/public/gui/gamesetup/gamesetup.js

@@ -1700 +1700 @@
 
     var message = "";
     if ("text" in msg && msg.text)
         message = escapeText(msg.text);
 
+    // Kick / ban players
+    if ("text" in msg)
+    {
+        let split = msg.text.split(/\s/);
+        let kick = msg.text.indexOf("/kick") == 0;
+        let ban = msg.text.indexOf("/ban") == 0;
+        let playerGUID = Engine.GetPlayerGUID();
+        if (kick || ban)
+        {
+            if (!g_IsNetworked || !g_IsController || msg.guid != playerGUID)
+                return;
+            let trimmed = msg.text.substr(split[0].length + 1);
+            let matched = "";
+            // Reject names which don't match or are a superset of the intended name.
+            for each (let player in g_PlayerAssignments)
+                if (trimmed.indexOf(player.name) == 0 && player.name.length > matched.length)
+                    matched = player.name;
+            // Prevent the host from kicking him/herself
+            if (matched.length && matched != g_PlayerAssignments[playerGUID].name)
+            {
+                // Sending the message takes a while, so we phrase this past tense.
+                // The text should be translated for each client individually (see #3304)
+                Engine.SendNetworkChat(matched + " has been " + (ban ? "banned" : "kicked") + ".");
+                Engine.KickPlayer(matched, ban);
+            }
+            return;
+        }
+    }
+
     // TODO: Maybe host should have distinct font/color?
     var color = "white";
 
     if (msg.guid && g_PlayerAssignments[msg.guid] && g_PlayerAssignments[msg.guid].player != -1)
     {

binaries/data/mods/public/gui/session/messages.js

@@ -241 +241 @@
             obj.caption = translate("Connection to the server has been authenticated.");
             obj.hidden = false;
             break;
         case "disconnected":
             g_Disconnected = true;
-            obj.caption = translate("Connection to the server has been lost.") + "\n\n" + translate("The game has ended.");
+            obj.caption = translate("Connection to the server has been lost.") + "\n" +
+                getDisconnectReason(message.reason) + "\n" + translate("The game has ended.");
             obj.hidden = false;
             break;
         default:
             error("Unrecognised netstatus type '" + message.status + "'");
             break;
@@ -325 +326 @@
 function submitChatInput()
 {
     var input = Engine.GetGUIObjectByName("chatInput");
     var text = input.caption;
     var isCheat = false;
+
     if (text.length)
     {
+        // Check cheats
         if (!g_IsObserver && g_Players[Engine.GetPlayerID()].cheatsEnabled)
         {
             for each (var cheat in Object.keys(cheats))
             {
                 // Line must start with the cheat.
@@ -374 +377 @@
                 isCheat = true;
                 break;
             }
         }
 
-        // Observers should only send messages to "/all"
-        if (!isCheat && (!g_IsObserver || text.indexOf("/") == -1 || text.indexOf("/all ") == 0))
+        if (!isCheat)
         {
-            if (Engine.GetGUIObjectByName("toggleTeamChat").checked)
-                text = "/team " + text;
-
-            if (g_IsNetworked)
-                Engine.SendNetworkChat(text);
+            if (text.trim() == "/list")
+                addChatMessage({ "type": "clientlist", "guid": "local"});
             else
-                addChatMessage({ "type": "message", "guid": "local", "text": text });
+            {
+                if (Engine.GetGUIObjectByName("toggleTeamChat").checked)
+                    text = "/team " + text;
+
+                if (g_IsNetworked)
+                    Engine.SendNetworkChat(text);
+                else
+                    addChatMessage({ "type": "message", "guid": "local", "text": text });
+            }
         }
         input.caption = ""; // Clear chat input
     }
 
     input.blur(); // Remove focus
@@ -453 +460 @@
         if (!g_IsNetworked && msg.player == Engine.GetPlayerID())
             formatted = translate("You have been defeated.");
         else
             formatted = sprintf(translate("%(player)s has been defeated."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
+    case "clientlist":
+        let userlist = Object.keys(playerAssignments).sort(function(a,b)
+        {
+            let playerA = playerAssignments[a].player;
+            let playerB = playerAssignments[b].player;
+            if (playerA == -1 || playerB == -1)
+                return 1;
+            else
+                return playerA - playerB;
+        }).map(guid => playerAssignments[guid].name).join(",");
+        formatted = sprintf(translate("Users: %(users)s."), { "users": userlist });
+        break;
     case "diplomacy":
         var message;
         if (msg.player == Engine.GetPlayerID())
         {
             [username, playerColor] = getUsernameAndColor(msg.player1);
@@ -601 +620 @@
 }
 
 // Parses chat messages for commands.
 function parseChatCommands(msg, playerAssignments)
 {
+    let ban = false;
     // Only interested in messages that start with '/'.
     if (!msg.text || msg.text[0] != '/')
         return;
 
-    var sender;
+    let playerGUID = Engine.GetPlayerGUID();
+    let sender;
     if (playerAssignments[msg.guid])
         sender = playerAssignments[msg.guid].player;
     else
         sender = msg.player;
 
     // TODO: It would be nice to display multiple different contexts.
     // It should be made clear that only players matching the union of those receive the message.
     var recurse = false;
     var split = msg.text.split(/\s/);
-
+    let trimmed, matched;
     // Parse commands embedded in the message.
     switch (split[0])
     {
     case "/all":
         // Resets values that 'team' or 'enemy' may have set.
@@ -627 +648 @@
         msg.hide = false;
         recurse = true;
         break;
     case "/team":
         // Check if we are in a team.
-        if (g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
+        if (!g_IsObserver && g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
         {
             if (g_Players[Engine.GetPlayerID()].team != g_Players[sender].team)
                 msg.hide = true;
             else
                 msg.context = translate("Team");
@@ -641 +662 @@
         recurse = true;
         break;
     case "/ally":
     case "/allies":
         // Check if we sent the message, or are the sender's (mutual) ally
-        if (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isMutualAlly[Engine.GetPlayerID()]))
+        if (!g_IsObserver && (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isMutualAlly[Engine.GetPlayerID()])))
             msg.context = translate("Ally");
         else
             msg.hide = true;
 
         recurse = true;
         break;
     case "/enemy":
     case "/enemies":
         // Check if we sent the message, or are the sender's enemy
-        if (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isEnemy[Engine.GetPlayerID()]))
+        if (!g_IsObserver && (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isEnemy[Engine.GetPlayerID()])))
             msg.context = translate("Enemy");
         else
             msg.hide = true;
 
         recurse = true;
         break;
     case "/me":
         msg.action = true;
         break;
+    case "/ban":
+        ban = true; // handle in the "kick" case
+    case "/kick":
+        msg.hide = true;
+        if (!g_IsNetworked || !g_IsController || msg.guid != playerGUID)
+            break;
+        trimmed = msg.text.substr(split[0].length + 1);
+        matched = "";
+        // Reject names which don't match or are a superset of the intended name.
+        for each (let player in playerAssignments)
+            if (trimmed.indexOf(player.name) == 0 && player.name.length > matched.length)
+                matched = player.name;
+        // Prevent the host from kicking him/herself
+        if (matched.length && matched != g_PlayerAssignments[playerGUID].name)
+        {
+            Engine.KickPlayer(matched, ban);
+            // TODO: The text should be translated for each client individually (see #3304)
+            submitChatDirectly(matched + " has been " + (ban ? "banned" : "kicked") + ".");
+        }
+        return;
     case "/msg":
-        var trimmed = msg.text.substr(split[0].length + 1);
-        var matched = "";
+        trimmed = msg.text.substr(split[0].length + 1);
+        matched = "";
+
+        // Don't show private messages from observers to players
+        if (g_PlayerAssignments[msg.guid].player == -1 && g_PlayerAssignments[playerGUID].player != -1)
+        {
+            msg.hide = true;
+            return;
+        }
 
         // Reject names which don't match or are a superset of the intended name.
         for each (var player in playerAssignments)
             if (trimmed.indexOf(player.name + " ") == 0 && player.name.length > matched.length)
                 matched = player.name;
 
         // If the local player's name was the longest one matched, show the message.
-        var playerName = g_Players[Engine.GetPlayerID()].name;
-        if (matched.length && (matched == playerName || sender == Engine.GetPlayerID()))
+        // Show the message only for sender and recipient.
+        if (matched.length && (msg.guid == playerGUID || matched == g_PlayerAssignments[playerGUID].name))
         {
             msg.context = translate("Private");
             msg.text = trimmed.substr(matched.length + 1);
             msg.hide = false; // Might override team message hiding.
             return;

binaries/data/mods/public/gui/session/session.xml

@@ -5 +5 @@
 <script file="gui/common/colorFades.js"/>
 <script file="gui/common/functions_civinfo.js"/>
 <script file="gui/common/functions_global_object.js"/>
 <script file="gui/common/functions_utility.js"/>
 <script file="gui/common/l10n.js"/>
+<script file="gui/common/network.js"/>
 <script file="gui/common/music.js"/>
 <script file="gui/common/timer.js"/>
 <script file="gui/common/tooltips.js"/>
 <!-- load all scripts in this directory -->
 <script directory="gui/session/"/>

source/gui/scripting/ScriptFunctions.cpp

@@ -186 +186 @@
     if (g_Game)
         return g_Game->GetPlayerID();
     return -1;
 }
 
+std::string GetPlayerGUID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+    if (g_NetServer)
+        return g_NetServer->GetHostGUID();
+    else if (g_NetClient)
+        return g_NetClient->GetGUID();
+    else
+        return "";
+}
+
 void SetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int id)
 {
     if (g_Game)
         g_Game->SetPlayerID(id);
 }
@@ -345 +355 @@
     SAFE_DELETE(g_NetServer);
     SAFE_DELETE(g_NetClient);
     SAFE_DELETE(g_Game);
 }
 
+void KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring playerName, bool ban)
+{
+    if (g_NetServer)
+        g_NetServer->KickPlayer(playerName, ban);
+}
+
 JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
 {
     if (!g_NetClient)
         return JS::UndefinedValue();
 
@@ -954 +970 @@
     scriptInterface.RegisterFunction<void, JS::HandleValue, int, &StartGame>("StartGame");
     scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
     scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
     scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
     scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
+    scriptInterface.RegisterFunction<void, std::wstring, bool, &KickPlayer>("KickPlayer");
     scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
     scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
     scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
     scriptInterface.RegisterFunction<void, std::string, int, &SetNetworkPlayerStatus>("SetNetworkPlayerStatus");
     scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
@@ -977 +994 @@
     scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
 
     // Misc functions
     scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
     scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
+    scriptInterface.RegisterFunction<std::string, &GetPlayerGUID>("GetPlayerGUID");
     scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
     scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
     scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
     scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
     scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");

source/network/NetClient.cpp

@@ -139 +139 @@
     ENSURE(!m_Session); // must be called before we start the connection
 
     m_UserName = username;
 }
 
+CStr CNetClient::GetGUID()
+{
+    return m_GUID;
+}
+
 bool CNetClient::SetupConnection(const CStr& server)
 {
     CNetClientSession* session = new CNetClientSession(*this);
     bool ok = session->Connect(PS_DEFAULT_PORT, server);
     SetAndOwnSession(session);

source/network/NetClient.h

@@ -86 +86 @@
      * Set the user's name that will be displayed to all players.
      * This must not be called after the connection setup.
      */
     void SetUserName(const CStrW& username);
 
+    /** Returns the GUID of the client. */
+    CStr GetGUID();
+
     /**
      * Set up a connection to the remote networked server.
      * @param server IP address or host name to connect to
      * @return true on success, false on connection failure
      */

source/network/NetHost.h

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2015 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
@@ -60 +60 @@
 enum NetDisconnectReason
 {
     NDR_UNKNOWN = 0,
     NDR_UNEXPECTED_SHUTDOWN,
     NDR_INCORRECT_PROTOCOL_VERSION,
-    NDR_SERVER_ALREADY_IN_GAME
+    NDR_SERVER_ALREADY_IN_GAME,
+    NDR_KICKED,
+    NDR_BANNED
 };
 
 class CNetHost
 {
 public:

source/network/NetServer.cpp

@@ -127 +127 @@
 
     m_ServerTurnManager = NULL;
 
     m_ServerName = DEFAULT_SERVER_NAME;
     m_WelcomeMessage = DEFAULT_WELCOME_MESSAGE;
+    m_HostGUID = std::string();
 }
 
 CNetServerWorker::~CNetServerWorker()
 {
     if (m_State != SERVER_STATE_UNCONNECTED)
@@ -604 +605 @@
     session->SetFirstState(NSS_HANDSHAKE);
 }
 
 bool CNetServerWorker::HandleConnect(CNetServerSession* session)
 {
+    CNetServerWorker& server = session->GetServer();
+
+    // Disconnect banned IPs
+    std::string ipAddress = session -> GetIPAddress();
+    if(std::find(server.m_BannedIPs.begin(), server.m_BannedIPs.end(), ipAddress) != server.m_BannedIPs.end())
+    {
+        session->Disconnect(NDR_BANNED);
+        return false;
+    }
+
+    // Send handshake challenge
     CSrvHandshakeMessage handshake;
     handshake.m_Magic = PS_PROTOCOL_MAGIC;
     handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
     handshake.m_SoftwareVersion = PS_PROTOCOL_VERSION;
     return session->SendMessage(&handshake);
@@ -615 +627 @@
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
     AddPlayer(session->GetGUID(), session->GetUserName());
 
+    if (m_HostGUID == "")
+        m_HostGUID = session->GetGUID();
+
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
     session->SendMessage(&gameSetupMessage);
 
     CPlayerAssignmentMessage assignMessage;
@@ -630 +645 @@
 {
     RemovePlayer(session->GetGUID());
 
     if (m_ServerTurnManager && session->GetCurrState() != NSS_JOIN_SYNCING)
         m_ServerTurnManager->UninitialiseClient(session->GetHostID()); // TODO: only for non-observers
-
-    // TODO: ought to switch the player controlled by that client
-    // back to AI control, or something?
 }
 
 void CNetServerWorker::AddPlayer(const CStr& guid, const CStrW& name)
 {
     // Find all player IDs in active use; we mustn't give them to a second player (excluding the unassigned ID: -1)
@@ -707 +719 @@
         it->second.m_Status = 0;
 
     SendPlayerAssignments();
 }
 
+void CNetServerWorker::KickPlayer(const CStrW& playerName, bool ban)
+{
+    if (ban)
+    {
+        // Add playername to blacklist
+        if (std::find(m_BannedPlayers.begin(), m_BannedPlayers.end(), playerName) == m_BannedPlayers.end())
+            m_BannedPlayers.push_back(playerName);
+
+        // Add IP address to blacklist
+        std::string ipAddress = GetPlayerIPAddress(playerName);
+        if (std::find(m_BannedIPs.begin(), m_BannedIPs.end(), ipAddress) == m_BannedIPs.end())
+            m_BannedIPs.push_back(ipAddress);
+    }
+
+    // Disconnect everyone with that nick except the host
+    for (auto session : m_Sessions)
+    {
+        if (session->GetUserName() == playerName && session->GetGUID() != m_HostGUID)
+            session->Disconnect(ban ? NDR_BANNED : NDR_KICKED);
+    }
+}
+
+std::string CNetServerWorker::GetPlayerIPAddress(const CStrW& playerName)
+{
+    std::string ipAddress = "(error)";
+    for (auto session : m_Sessions)
+    {
+        if (session->GetUserName() == playerName)
+            return session->GetIPAddress();
+    }
+    return ipAddress;
+}
+
+std::string CNetServerWorker::GetHostGUID()
+{
+    return m_HostGUID;
+}
+
 void CNetServerWorker::AssignPlayer(int playerID, const CStr& guid)
 {
     // Remove anyone who's already assigned to this player
     for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
     {
@@ -764 +814 @@
     ENSURE(event->GetType() == (uint)NMT_CLIENT_HANDSHAKE);
 
     CNetServerSession* session = (CNetServerSession*)context;
     CNetServerWorker& server = session->GetServer();
 
+    // Check protocol version
     CCliHandshakeMessage* message = (CCliHandshakeMessage*)event->GetParamRef();
     if (message->m_ProtocolVersion != PS_PROTOCOL_VERSION)
     {
         session->Disconnect(NDR_INCORRECT_PROTOCOL_VERSION);
         return false;
     }
 
+    // Send handshake response
     CSrvHandshakeResponseMessage handshakeResponse;
     handshakeResponse.m_UseProtocolVersion = PS_PROTOCOL_VERSION;
     handshakeResponse.m_Message = server.m_WelcomeMessage;
     handshakeResponse.m_Flags = 0;
     session->SendMessage(&handshakeResponse);
@@ -791 +843 @@
 
     CAuthenticateMessage* message = (CAuthenticateMessage*)event->GetParamRef();
 
     CStrW username = server.DeduplicatePlayerName(SanitisePlayerName(message->m_Name));
 
+    // Disconnect banned usernames
+    if(std::find(server.m_BannedPlayers.begin(), server.m_BannedPlayers.end(), username) != server.m_BannedPlayers.end())
+    {
+        session->Disconnect(NDR_BANNED);
+        return true;
+    }
+
     bool isRejoining = false;
 
     if (server.m_State != SERVER_STATE_PREGAME)
     {
 //      isRejoining = true; // uncomment this to test rejoining even if the player wasn't connected previously
@@ -1145 +1204 @@
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_PlayerReadyQueue.push_back(std::make_pair(guid, ready));
 }
 
+void CNetServer::KickPlayer(const CStrW& playerName, bool ban)
+{
+    CScopeLock lock(m_Worker->m_WorkerMutex);
+    m_Worker->KickPlayer(playerName, ban);
+}
+
+std::string CNetServer::GetHostGUID()
+{
+    CScopeLock lock(m_Worker->m_WorkerMutex);
+    return m_Worker->GetHostGUID();
+}
+
 void CNetServer::ClearAllPlayerReady()
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_PlayerResetReadyQueue.push_back(false);
 }

source/network/NetServer.h

@@ -120 +120 @@
      * The given GUID will be (re)assigned to the given player ID.
      * Any player currently using that ID will be unassigned.
      * The changes will be asynchronously propagated to all clients.
      */
     void AssignPlayer(int playerID, const CStr& guid);
-    
+
     /**
      * Call from the GUI to update the player readiness.
      * The changes will be asynchronously propagated to all clients.
      */
     void SetPlayerReady(const CStr& guid, int ready);
@@ -132 +132 @@
     /**
      * Call from the GUI to set the all player readiness to 0.
      * The changes will be asynchronously propagated to all clients.
      */
     void ClearAllPlayerReady();
-    
+
+    /**
+     * Disconnects a player from the gamesetup / session.
+     */
+    void KickPlayer(const CStrW& playerName, bool ban);
+
+    /**
+     * Returns the GUID of the host.
+     */
+    std::string GetHostGUID();
+
     /**
      * Call from the GUI to asynchronously notify all clients that they should start loading the game.
      */
     void StartGame();
 
@@ -181 +191 @@
      * Send a message to the given network peer.
      */
     bool SendMessage(ENetPeer* peer, const CNetMessage* message);
 
     /**
+     * Disconnected a player from the match / gamesetup and optionally prevents him/her from rejoining.
+     */
+    void KickPlayer(const CStrW& playerName, bool ban);
+
+    /**
      * Send a message to all clients who have completed the full connection process
      * (i.e. are in the pre-game or in-game states).
      */
     bool Broadcast(const CNetMessage* message);
 
+    /**
+     * Returns the IP address of the given connected player.
+     */
+    std::string GetPlayerIPAddress(const CStrW& playerName);
+
 private:
     friend class CNetServer;
     friend class CNetFileReceiveTask_ServerRejoin;
 
     CNetServerWorker(int autostartPlayers);
@@ -244 +264 @@
     void SetTurnLength(u32 msecs);
 
     void AddPlayer(const CStr& guid, const CStrW& name);
     void RemovePlayer(const CStr& guid);
     void SetPlayerReady(const CStr& guid, const int ready); 
+    std::string GetHostGUID();
     void SendPlayerAssignments();
     void ClearAllPlayerReady();
 
     void SetupSession(CNetServerSession* session);
     bool HandleConnect(CNetServerSession* session);
@@ -269 +290 @@
 
     void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
 
     void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
-
     /**
      * Internal script context for (de)serializing script messages,
      * and for storing game attributes.
      * (TODO: we shouldn't bother deserializing (except for debug printing of messages),
      * we should just forward messages blindly and efficiently.)
@@ -285 +305 @@
     /**
      * Stores the most current game attributes.
      */
     DefPersistentRooted<JS::Value> m_GameAttributes;
 
+    std::vector<std::string> m_BannedIPs;
+    std::vector<std::wstring> m_BannedPlayers;
+
     int m_AutostartPlayers;
 
     ENetHost* m_Host;
     std::vector<CNetServerSession*> m_Sessions;
 
@@ -301 +324 @@
 
     u32 m_NextHostID;
 
     CNetServerTurnManager* m_ServerTurnManager;
 
+    std::string m_HostGUID;
+
     /**
      * A copy of all simulation commands received so far, indexed by
      * turn number, to simplify support for rejoining etc.
      * TODO: verify this doesn't use too much RAM.
      */

source/network/NetSession.cpp

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2015 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
@@ -173 +173 @@
 CNetServerSession::CNetServerSession(CNetServerWorker& server, ENetPeer* peer) :
     m_Server(server), m_FileTransferer(this), m_Peer(peer)
 {
 }
 
+std::string CNetServerSession::GetIPAddress()
+{
+    char ipAddress[256] = "(error)";
+    enet_address_get_host_ip(&(m_Peer->address), ipAddress, ARRAY_SIZE(ipAddress));
+    return std::string(ipAddress);
+}
+
 void CNetServerSession::Disconnect(u32 reason)
 {
     Update((uint)NMT_CONNECTION_LOST, NULL);
 
     enet_peer_disconnect(m_Peer, reason);

source/network/NetSession.h

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* Copyright (C) 2015 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
@@ -121 +121 @@
 
     u32 GetHostID() const { return m_HostID; }
     void SetHostID(u32 id) { m_HostID = id; }
 
     /**
+     * Returns the IP address of the client.
+     */
+    std::string GetIPAddress();
+
+    /**
      * 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.
      * The server will not receive any further messages sent via this session.
      */