Ticket #3241: t3241_kick_v6.6.2.patch

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

@@ +1 @@
+/**
+ * Get a human readable version of the given disconnect reason.
+ *
+ * @param reason {number}
+ * @returns {string}
+ */
 function getDisconnectReason(id)
 {
     // Must be kept in sync with source/network/NetHost.h
     switch (id)
     {
     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 is loading, please try later");
     case 4: return translate("Game has already started, no observers allowed");
+    case 5: return translate("You have been kicked from the match");
+    case 6: return translate("You have been banned from the match");
     default: return sprintf(translate("\\[Invalid value %(id)s]"), { "id": id });
     }
 }
 
+/**
+ * Show the disconnect reason in a message box.
+ *
+ * @param {number} reason
+ */
 function reportDisconnect(reason)
 {
-    var reasontext = getDisconnectReason(reason);
+    // Translation: States the reason why the client disconnected from the server.
+    var reasonText = sprintf(translate("Reason: %(reason)s."), { "reason": getDisconnectReason(reason) })
+    messageBox(400, 200, translate("Lost connection to the server.") + "\n\n" + reasonText, translate("Disconnected"), 2);
+}
+
+/**
+ * Get usernames sorted by player slot, observers last.
+ * Requires g_PlayerAssignments.
+ *
+ * @returns {string[]}
+ */
+function getUsernameList()
+{
+    return Object.keys(g_PlayerAssignments).sort((guidA, guidB) => {
+
+        var playerIdA = g_PlayerAssignments[guidA].player;
+        var playerIdB = g_PlayerAssignments[guidB].player;
+
+        // Sort observers last
+        if (playerIdA == -1) return +1;
+        if (playerIdB == -1) return -1;
+
+        // Sort players
+        return playerIdA - playerIdB;
+
+    }).map(guid => g_PlayerAssignments[guid].name);
+}
 
-    messageBox(400, 200,
-        translate("Lost connection to the server.") + "\n\n" + sprintf(translate("Reason: %(reason)s."), { reason: reasontext }),
-        translate("Disconnected"), 2);
+/**
+ * Execute a command locally. Requires addChatMessage.
+ *
+ * @param {string} input
+ * @returns {Boolean} whether a command was executed
+ */
+function executeNetworkCommand(input)
+{
+    if (input.indexOf("/") != 0)
+        return false;
+
+    var command = input.split(" ", 1)[0];
+    var argument = input.substr(command.length + 1);
+
+    switch (command)
+    {
+    case "/list":
+        addChatMessage({ "type": "clientlist", "guid": "local" });
+        return true;
+
+    case "/kick":
+        if (!Engine.KickPlayer(argument, false))
+            addChatMessage({ "type": "system", "text": sprintf(translate("Could not kick user %(name)s."), { "name": argument }) });
+        return true;
+
+    case "/ban":
+        if (!Engine.KickPlayer(argument, true))
+            addChatMessage({ "type": "system", "text": sprintf(translate("Could not ban user %(name)s."), { "name": argument }) });
+        return true;
+    }
+    return false;
 }

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

@@ -506 +506 @@
 
     case "chat":
         addChatMessage({ "type": "message", "guid": message.guid, "text": message.text });
         break;
 
+    case "kicked":
+        addChatMessage({ "type": "system", "text": "== " + sprintf(translate("%(username)s has been kicked"), { "username": message.username })});
+        break;
+
+    case "banned":
+        addChatMessage({ "type": "system", "text": "== " + sprintf(translate("%(username)s has been banned"), { "username": message.username })});
+        break;
+
     // Singular client to host message
     case "ready":
         g_ReadyChanged -= 1;
         if (g_ReadyChanged < 1 && g_PlayerAssignments[message.guid].player != -1)
             addChatMessage({ "type": "ready", "guid": message.guid, "ready": +message.status == 1 });
@@ -1774 +1782 @@
     var input = Engine.GetGUIObjectByName("chatInput");
     var text = input.caption;
     if (!text.length)
         return;
 
-    Engine.SendNetworkChat(text);
     input.caption = "";
+
+    if (executeNetworkCommand(text))
+        return;
+
+    Engine.SendNetworkChat(text);
 }
 
 function addChatMessage(msg)
 {
     var username = "";
@@ -1810 +1822 @@
     case "disconnect":
         var formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
         formatted = '[font="sans-bold-13"] ' + sprintf(translate("== %(message)s"), { "message": sprintf(translate("%(username)s has left"), { "username": formattedUsername }) }) + '[/font]';
         break;
 
+    case "clientlist":
+        formatted = sprintf(translate("Users: %(users)s"), { "users": getUsernameList().join(",") });
+        break;
+
+    case "system":
+        formatted = '[font="sans-bold-13"] ' + msg.text + '[/font]';
+        break;
+
     case "message":
         var formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
         var formattedUsernamePrefix = '[font="sans-bold-13"]' + sprintf(translate("<%(username)s>"), { "username": formattedUsername }) + '[/font]';
         formatted = sprintf(translate("%(username)s %(message)s"), { "username": formattedUsernamePrefix, "message": message });
         break;

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

@@ -267 +267 @@
             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.");
+            // Translation: States the reason why the client disconnected from the server.
+            let reason = sprintf(translate("Reason: %(reason)s."), { "reason": getDisconnectReason(message.reason) });
+            obj.caption = translate("Connection to the server has been lost.") + "\n" + reason + "\n" + translate("The game has ended.");
             obj.hidden = false;
             break;
         default:
             error("Unrecognised netstatus type '" + message.status + "'");
             break;
@@ -323 +325 @@
 
     case "rejoined":
         addChatMessage({ "type": "rejoined", "guid": message.guid });
         break;
 
+    case "kicked":
+        addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been kicked"), { "username": message.username })});
+        break;
+
+    case "banned":
+        addChatMessage({ "type": "system", "text": sprintf(translate("%(username)s has been banned"), { "username": message.username })});
+        break;
+
     // To prevent errors, ignore these message types that occur during autostart
     case "gamesetup":
     case "start":
         break;
 
@@ -357 +367 @@
     toggleChatWindow();
 
     if (!text.length)
         return;
 
+    if (executeNetworkCommand(text))
+        return;
+
     if (executeCheat(text))
         return;
 
     // Observers should only be able to chat with everyone.
     if (g_IsObserver && text.indexOf("/") == 0 && text.indexOf("/me ") != 0)
@@ -418 +431 @@
         formatted = sprintf(translate("%(player)s has left the game."), { "player": "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
     case "rejoined":
         formatted = sprintf(translate("%(player)s has rejoined the game."), { "player": "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
+    case "clientlist":
+        formatted = sprintf(translate("Users: %(users)s"), { "users": getUsernameList().join(",") });
+        break;
+    case "system":
+        formatted = msg.text;
+        break;
     case "defeat":
         // In singleplayer, the local player is "You". "You has" is incorrect.
         if (!g_IsNetworked && msg.player == Engine.GetPlayerID())
             formatted = translate("You have been defeated.");
         else

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

@@ -6 +6 @@
 <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/music.js"/>
+<script file="gui/common/network.js"/>
 <script file="gui/common/settings.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

@@ -351 +351 @@
     SAFE_DELETE(g_NetServer);
     SAFE_DELETE(g_NetClient);
     SAFE_DELETE(g_Game);
 }
 
+bool KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), CStrW playerName, bool ban)
+{
+    if (!g_NetServer)
+        return false;
+
+    return g_NetServer->KickPlayer(playerName, ban);
+}
+
 JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
 {
     if (!g_NetClient)
         return JS::UndefinedValue();
 
@@ -961 +969 @@
     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<bool, CStrW, 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");

source/network/NetClient.cpp

@@ -91 +91 @@
 
     AddTransition(NCS_PREGAME, (uint)NMT_CHAT, NCS_PREGAME, (void*)&OnChat, context);
     AddTransition(NCS_PREGAME, (uint)NMT_READY, NCS_PREGAME, (void*)&OnReady, context);
     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_GAME_START, NCS_LOADING, (void*)&OnGameStart, context);
     AddTransition(NCS_PREGAME, (uint)NMT_JOIN_SYNC_START, NCS_JOIN_SYNCING, (void*)&OnJoinSyncStart, context);
 
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_CHAT, NCS_JOIN_SYNCING, (void*)&OnChat, context);
     AddTransition(NCS_JOIN_SYNCING, (uint)NMT_GAME_SETUP, NCS_JOIN_SYNCING, (void*)&OnGameSetup, context);
@@ -108 +109 @@
     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_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_CHAT, NCS_INGAME, (void*)&OnChat, context);
     AddTransition(NCS_INGAME, (uint)NMT_GAME_SETUP, NCS_INGAME, (void*)&OnGameSetup, context);
     AddTransition(NCS_INGAME, (uint)NMT_PLAYER_ASSIGNMENT, NCS_INGAME, (void*)&OnPlayerAssignment, context);
     AddTransition(NCS_INGAME, (uint)NMT_SIMULATION_COMMAND, NCS_INGAME, (void*)&OnInGame, context);
     AddTransition(NCS_INGAME, (uint)NMT_SYNC_ERROR, NCS_INGAME, (void*)&OnInGame, context);
@@ -605 +607 @@
     client->PushGuiMessage(msg);
 
     return true;
 }
 
+bool CNetClient::OnKicked(void *context, CFsmEvent* event)
+{
+    ENSURE(event->GetType() == (uint)NMT_KICKED);
+
+    CNetClient* client = (CNetClient*)context;
+    JSContext* cx = client->GetScriptInterface().GetContext();
+
+    CKickedMessage* message = (CKickedMessage*)event->GetParamRef();
+    JS::RootedValue msg(cx);
+
+    client->GetScriptInterface().Eval("({})", &msg);
+    client->GetScriptInterface().SetProperty(msg, "username", message->m_Name);
+    if (message->m_Ban)
+        client->GetScriptInterface().SetProperty(msg, "type", std::string("banned"));
+    else
+        client->GetScriptInterface().SetProperty(msg, "type", std::string("kicked"));
+
+    client->PushGuiMessage(msg);
+
+    return true;
+}
+
 bool CNetClient::OnLoadedGame(void* context, CFsmEvent* event)
 {
     ENSURE(event->GetType() == (uint)NMT_LOADED_GAME);
 
     CNetClient* client = (CNetClient*)context;

source/network/NetClient.h

@@ -199 +199 @@
     static bool OnInGame(void* context, CFsmEvent* event);
     static bool OnGameStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncStart(void* context, CFsmEvent* event);
     static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
     static bool OnRejoined(void* context, CFsmEvent* event);
+    static bool OnKicked(void* context, CFsmEvent* event);
     static bool OnLoadedGame(void* context, CFsmEvent* event);
 
     /**
      * Take ownership of a session object, and use it for all network communication.
      */

source/network/NetHost.h

@@ -61 +61 @@
 {
     NDR_UNKNOWN = 0,
     NDR_UNEXPECTED_SHUTDOWN,
     NDR_INCORRECT_PROTOCOL_VERSION,
     NDR_SERVER_LOADING,
-    NDR_SERVER_ALREADY_IN_GAME
+    NDR_SERVER_ALREADY_IN_GAME,
+    NDR_KICKED,
+    NDR_BANNED
 };
 
 class CNetHost
 {
 public:

source/network/NetMessage.cpp

@@ -133 +133 @@
 
     case NMT_REJOINED:
         pNewMessage = new CRejoinedMessage;
         break;
 
+    case NMT_KICKED:
+        pNewMessage = new CKickedMessage;
+        break;
+
     case NMT_LOADED_GAME:
         pNewMessage = new CLoadedGameMessage;
         break;
 
     case NMT_SERVER_HANDSHAKE:

source/network/NetMessages.h

@@ -26 +26 @@
 #include "ps/CStr.h"
 #include "scriptinterface/ScriptVal.h"
 
 #define PS_PROTOCOL_MAGIC               0x5073013f      // 'P', 's', 0x01, '?'
 #define PS_PROTOCOL_MAGIC_RESPONSE      0x50630121      // 'P', 'c', 0x01, '!'
-#define PS_PROTOCOL_VERSION             0x01010007      // Arbitrary protocol
+#define PS_PROTOCOL_VERSION             0x01010008      // Arbitrary protocol
 #define PS_DEFAULT_PORT                 0x5073          // 'P', 's'
 
 // Defines the list of message types. The order of the list must not change.
 // The message types having a negative value are used internally and not sent
 // over the network. The message types used for network communication have 
@@ -56 +56 @@
     NMT_FILE_TRANSFER_ACK,
 
     NMT_JOIN_SYNC_START,
 
     NMT_REJOINED,
+    NMT_KICKED,
 
     NMT_LOADED_GAME,
     NMT_GAME_START,
     NMT_END_COMMAND_BATCH,
     NMT_SYNC_CHECK, // OOS-detection hash checking
@@ -159 +160 @@
 
 START_NMT_CLASS_(Rejoined, NMT_REJOINED)
     NMT_FIELD(CStr8, m_GUID)
 END_NMT_CLASS()
 
+START_NMT_CLASS_(Kicked, NMT_KICKED)
+    NMT_FIELD(CStrW, m_Name)
+    NMT_FIELD_INT(m_Ban, bool, 1)
+END_NMT_CLASS()
+
 START_NMT_CLASS_(LoadedGame, NMT_LOADED_GAME)
     NMT_FIELD_INT(m_CurrentTurn, u32, 4)
 END_NMT_CLASS()
 
 START_NMT_CLASS_(GameStart, NMT_GAME_START)

source/network/NetServer.cpp

@@ -119 +119 @@
 
 CNetServerWorker::CNetServerWorker(int autostartPlayers) :
     m_AutostartPlayers(autostartPlayers),
     m_Shutdown(false),
     m_ScriptInterface(NULL),
-    m_NextHostID(1), m_Host(NULL), m_Stats(NULL)
+    m_NextHostID(1), m_Host(NULL), m_HostGUID(), m_Stats(NULL)
 {
     m_State = SERVER_STATE_UNCONNECTED;
 
     m_ServerTurnManager = NULL;
 
@@ -472 +472 @@
 
     switch (event.type)
     {
     case ENET_EVENT_TYPE_CONNECT:
     {
-        // Report the client address
-        char hostname[256] = "(error)";
-        enet_address_get_host_ip(&event.peer->address, hostname, ARRAY_SIZE(hostname));
-        LOGMESSAGE("Net server: Received connection from %s:%u", hostname, (unsigned int)event.peer->address.port);
-
         // Set up a session object for this peer
-
         CNetServerSession* session = new CNetServerSession(*this, event.peer);
 
+        // Report the client address
+        LOGMESSAGE("Net server: Received connection from %s:%u", session->GetIPAddress().c_str(), (unsigned int)event.peer->address.port);
+
         m_Sessions.push_back(session);
 
         SetupSession(session);
 
         ENSURE(event.peer->data == NULL);
@@ -608 +605 @@
     session->SetFirstState(NSS_HANDSHAKE);
 }
 
 bool CNetServerWorker::HandleConnect(CNetServerSession* session)
 {
+    CNetServerWorker& server = session->GetServer();
+
+    // Disconnect banned IPs
+    if (std::find(server.m_BannedIPs.begin(), server.m_BannedIPs.end(), session->GetIPAddress()) != 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);
@@ -619 +626 @@
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
     AddPlayer(session->GetGUID(), session->GetUserName());
 
+    // Host is the first to join
+    if (m_HostGUID.empty())
+        m_HostGUID = session->GetGUID();
+
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
     session->SendMessage(&gameSetupMessage);
 
     CPlayerAssignmentMessage assignMessage;
@@ -711 +722 @@
         it->second.m_Status = 0;
 
     SendPlayerAssignments();
 }
 
+bool CNetServerWorker::KickPlayer(const CStrW& playerName, const bool ban)
+{
+    // Find the user with that name
+    std::vector<CNetServerSession*>::iterator it = std::find_if(m_Sessions.begin(), m_Sessions.end(),
+        [&](CNetServerSession* session) { return session->GetUserName() == playerName; });
+
+    // and return if no one or the host has that name
+    if (it == m_Sessions.end() || (*it)->GetGUID() == m_HostGUID)
+        return false;
+
+    if (ban)
+    {
+        // Remember name
+        if (std::find(m_BannedPlayers.begin(), m_BannedPlayers.end(), playerName) == m_BannedPlayers.end())
+            m_BannedPlayers.push_back(playerName);
+
+        // Remember IP address
+        CStr ipAddress = GetPlayerIPAddress(playerName);
+        if (ipAddress != "" && std::find(m_BannedIPs.begin(), m_BannedIPs.end(), ipAddress) == m_BannedIPs.end())
+            m_BannedIPs.push_back(ipAddress);
+    }
+
+    // Disconnect that user
+    (*it)->Disconnect(ban ? NDR_BANNED : NDR_KICKED);
+
+    // Send message notifying other clients
+    CKickedMessage kickedMessage;
+    kickedMessage.m_Name = playerName;
+    kickedMessage.m_Ban = ban;
+    Broadcast(&kickedMessage);
+
+    return true;
+}
+
+CStr CNetServerWorker::GetPlayerIPAddress(const CStrW& playerName)
+{
+    for (CNetServerSession* session : m_Sessions)
+        if (session->GetUserName() == playerName)
+            return session->GetIPAddress();
+    return "";
+}
+
 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)
     {
@@ -768 +821 @@
     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);
@@ -802 +857 @@
     }
 
     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;
+    }
+
     // Optionally allow observers to join after the game has started
     bool observerLateJoin = false;
     ScriptInterface& scriptInterface = server.GetScriptInterface();
     JSContext* cx = scriptInterface.GetContext();
     JSAutoRequest rq(cx);
@@ -1166 +1228 @@
 bool CNetServer::SetupConnection()
 {
     return m_Worker->SetupConnection();
 }
 
+bool CNetServer::KickPlayer(const CStrW& playerName, const bool ban)
+{
+    CScopeLock lock(m_Worker->m_WorkerMutex);
+    return m_Worker->KickPlayer(playerName, ban);
+}
+
 void CNetServer::AssignPlayer(int playerID, const CStr& guid)
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_AssignPlayerQueue.emplace_back(playerID, guid);
 }

source/network/NetServer.h

@@ -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.
+     */
+    bool KickPlayer(const CStrW& playerName, const bool ban);
+
     /**
      * Call from the GUI to asynchronously notify all clients that they should start loading the game.
      */
     void StartGame();
 
@@ -181 +186 @@
      * 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.
+     */
+    bool KickPlayer(const CStrW& playerName, const 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.
+     */
+    CStr GetPlayerIPAddress(const CStrW& playerName);
+
 private:
     friend class CNetServer;
     friend class CNetFileReceiveTask_ServerRejoin;
 
     CNetServerWorker(int autostartPlayers);
@@ -244 +259 @@
     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); 
+    CStr GetHostGUID();
     void SendPlayerAssignments();
     void ClearAllPlayerReady();
 
     void SetupSession(CNetServerSession* session);
     bool HandleConnect(CNetServerSession* session);
@@ -297 +313 @@
     NetServerState m_State;
 
     CStrW m_ServerName;
     CStrW m_WelcomeMessage;
 
+    std::vector<CStr> m_BannedIPs;
+    std::vector<CStrW> m_BannedPlayers;
+
     u32 m_NextHostID;
 
     CNetServerTurnManager* m_ServerTurnManager;
 
+    CStr 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
@@ -108 +108 @@
         case ENET_EVENT_TYPE_CONNECT:
         {
             ENSURE(event.peer == m_Server);
 
             // Report the server address
-            char hostname[256] = "(error)";
+            char hostname[256] = "";
             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();
 
@@ -173 +173 @@
 CNetServerSession::CNetServerSession(CNetServerWorker& server, ENetPeer* peer) :
     m_Server(server), m_FileTransferer(this), m_Peer(peer)
 {
 }
 
+CStr CNetServerSession::GetIPAddress()
+{
+    char ipAddress[256] = "";
+    if (enet_address_get_host_ip(&(m_Peer->address), ipAddress, ARRAY_SIZE(ipAddress)) < 0)
+    {
+        LOGERROR("Could not get IP address of a client!");
+        return "";
+    }
+
+    return CStr(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.
+     */
+    CStr 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.
      */