Track bytes sent and received in Network.

src/openrct2/network/Network.cpp

@@ -184,6 +184,8 @@ public:
     void Client_Send_OBJECTS(const std::vector<std::string>& objects);
     void Server_Send_OBJECTS(NetworkConnection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const;
 
+    NetworkStats_t GetStats() const;
+
     std::vector<std::unique_ptr<NetworkPlayer>> player_list;
     std::vector<std::unique_ptr<NetworkGroup>> group_list;
     NetworkKey _key;
@@ -205,6 +207,7 @@ private:
     void ProcessPacket(NetworkConnection& connection, NetworkPacket& packet);
     void AddClient(std::unique_ptr<ITcpSocket>&& socket);
     void RemoveClient(std::unique_ptr<NetworkConnection>& connection);
+
     NetworkPlayer* AddPlayer(const utf8* name, const std::string& keyhash);
     std::string MakePlayerNameUnique(const std::string& name);
 
@@ -1396,6 +1399,27 @@ void Network::Server_Send_OBJECTS(NetworkConnection& connection, const std::vect
     connection.QueuePacket(std::move(packet));
 }
 
+NetworkStats_t Network::GetStats() const
+{
+    NetworkStats_t stats = {};
+    if (mode == NETWORK_MODE_CLIENT)
+    {
+        stats = _serverConnection->Stats;
+    }
+    else
+    {
+        for (auto& connection : client_connection_list)
+        {
+            for (size_t n = 0; n < NETWORK_STATISTICS_GROUP_MAX; n++)
+            {
+                stats.bytesReceived[n] += connection->Stats.bytesReceived[n];
+                stats.bytesSent[n] += connection->Stats.bytesSent[n];
+            }
+        }
+    }
+    return stats;
+}
+
 void Network::Server_Send_AUTH(NetworkConnection& connection)
 {
     uint8_t new_playerid = 0;
@@ -1412,7 +1436,6 @@ void Network::Server_Send_AUTH(NetworkConnection& connection)
     connection.QueuePacket(std::move(packet));
     if (connection.AuthStatus != NETWORK_AUTH_OK && connection.AuthStatus != NETWORK_AUTH_REQUIREPASSWORD)
     {
-        connection.SendQueuedPackets();
         connection.Socket->Disconnect();
     }
 }
@@ -1538,6 +1561,7 @@ void Network::Client_Send_GAMECMD(
     std::unique_ptr<NetworkPacket> packet(NetworkPacket::Allocate());
     *packet << (uint32_t)NETWORK_COMMAND_GAMECMD << gCurrentTicks << eax << (ebx | GAME_COMMAND_FLAG_NETWORKED) << ecx << edx
             << esi << edi << ebp << callback;
+
     _serverConnection->QueuePacket(std::move(packet));
 }
 
@@ -1569,7 +1593,6 @@ void Network::Client_Send_GAME_ACTION(const GameAction* action)
     action->Serialise(stream);
 
     *packet << (uint32_t)NETWORK_COMMAND_GAME_ACTION << gCurrentTicks << action->GetType() << stream;
-
     _serverConnection->QueuePacket(std::move(packet));
 }
 
@@ -1616,6 +1639,7 @@ void Network::Server_Send_TICK()
         rct_sprite_checksum checksum = sprite_checksum();
         packet->WriteString(checksum.ToString().c_str());
     }
+
     SendPacketToClients(*packet);
 }
 
@@ -1666,7 +1690,6 @@ void Network::Server_Send_SETDISCONNECTMSG(NetworkConnection& connection, const
     *packet << (uint32_t)NETWORK_COMMAND_SETDISCONNECTMSG;
     packet->WriteString(msg);
     connection.QueuePacket(std::move(packet));
-    connection.SendQueuedPackets();
 }
 
 void Network::Server_Send_GAMEINFO(NetworkConnection& connection)
@@ -3853,6 +3876,11 @@ std::string network_get_version()
     return NETWORK_STREAM_ID;
 }
 
+NetworkStats_t network_get_stats()
+{
+    return gNetwork.GetStats();
+}
+
 #else
 int32_t network_get_mode()
 {
@@ -4085,4 +4113,12 @@ std::string network_get_version()
 {
     return "Multiplayer disabled";
 }
+uint64_t network_get_stats()
+{
+    return 0;
+}
+uint64_t network_get_bytes_sent()
+{
+    return 0;
+}
 #endif /* DISABLE_NETWORK */

src/openrct2/network/NetworkConnection.cpp

@@ -73,6 +73,9 @@ int32_t NetworkConnection::ReadPacket()
         if (InboundPacket.BytesTransferred == sizeof(InboundPacket.Size) + InboundPacket.Size)
         {
             _lastPacketTime = platform_get_ticks();
+
+            RecordPacketStats(InboundPacket, false);
+
             return NETWORK_READPACKET_SUCCESS;
         }
     }
@@ -94,7 +97,13 @@ bool NetworkConnection::SendPacket(NetworkPacket& packet)
     {
         packet.BytesTransferred += sent;
     }
-    return packet.BytesTransferred == tosend.size();
+
+    bool sendComplete = packet.BytesTransferred == tosend.size();
+    if (sendComplete)
+    {
+        RecordPacketStats(packet, true);
+    }
+    return sendComplete;
 }
 
 void NetworkConnection::QueuePacket(std::unique_ptr<NetworkPacket> packet, bool front)
@@ -175,4 +184,32 @@ void NetworkConnection::SetLastDisconnectReason(const rct_string_id string_id, v
     SetLastDisconnectReason(buffer);
 }
 
+void NetworkConnection::RecordPacketStats(const NetworkPacket& packet, bool sending)
+{
+    uint32_t packetSize = (uint32_t)packet.BytesTransferred;
+    uint32_t trafficGroup = NETWORK_STATISTICS_GROUP_BASE;
+
+    switch (packet.GetCommand())
+    {
+        case NETWORK_COMMAND_GAMECMD:
+        case NETWORK_COMMAND_GAME_ACTION:
+            trafficGroup = NETWORK_STATISTICS_GROUP_COMMANDS;
+            break;
+        case NETWORK_COMMAND_MAP:
+            trafficGroup = NETWORK_STATISTICS_GROUP_MAPDATA;
+            break;
+    }
+
+    if (sending)
+    {
+        Stats.bytesSent[trafficGroup] += packetSize;
+        Stats.bytesSent[NETWORK_STATISTICS_GROUP_TOTAL] += packetSize;
+    }
+    else
+    {
+        Stats.bytesReceived[trafficGroup] += packetSize;
+        Stats.bytesReceived[NETWORK_STATISTICS_GROUP_TOTAL] += packetSize;
+    }
+}
+
 #endif

src/openrct2/network/NetworkConnection.h

@@ -29,6 +29,7 @@ public:
     std::unique_ptr<ITcpSocket> Socket = nullptr;
     NetworkPacket InboundPacket;
     NETWORK_AUTH AuthStatus = NETWORK_AUTH_NONE;
+    NetworkStats_t Stats = {};
     NetworkPlayer* Player = nullptr;
     uint32_t PingTime = 0;
     NetworkKey Key;
@@ -53,6 +54,7 @@ private:
     uint32_t _lastPacketTime = 0;
     utf8* _lastDisconnectReason = nullptr;
 
+    void RecordPacketStats(const NetworkPacket& packet, bool sending);
     bool SendPacket(NetworkPacket& packet);
 };
 

src/openrct2/network/NetworkPacket.cpp

@@ -30,7 +30,7 @@ uint8_t* NetworkPacket::GetData()
     return &(*Data)[0];
 }
 
-int32_t NetworkPacket::GetCommand()
+int32_t NetworkPacket::GetCommand() const
 {
     if (Data->size() >= sizeof(uint32_t))
     {

src/openrct2/network/NetworkPacket.h

@@ -28,7 +28,7 @@ public:
     static std::unique_ptr<NetworkPacket> Duplicate(NetworkPacket& packet);
 
     uint8_t* GetData();
-    int32_t GetCommand();
+    int32_t GetCommand() const;
 
     void Clear();
     bool CommandRequiresAuth();

src/openrct2/network/NetworkTypes.h

@@ -95,3 +95,18 @@ template<typename T, size_t _TypeID> struct NetworkObjectId_t
 // there is no way to specialize templates if they have the exact symbol.
 using NetworkPlayerId_t = NetworkObjectId_t<int32_t, 0>;
 using NetworkRideId_t = NetworkObjectId_t<int32_t, 1>;
+
+enum NetworkStatisticsGroup
+{
+    NETWORK_STATISTICS_GROUP_TOTAL = 0, // Entire network traffic.
+    NETWORK_STATISTICS_GROUP_BASE,      // Messages such as Tick, Ping
+    NETWORK_STATISTICS_GROUP_COMMANDS,  // Command / Game actions
+    NETWORK_STATISTICS_GROUP_MAPDATA,
+    NETWORK_STATISTICS_GROUP_MAX,
+};
+
+struct NetworkStats_t
+{
+    uint64_t bytesReceived[NETWORK_STATISTICS_GROUP_MAX];
+    uint64_t bytesSent[NETWORK_STATISTICS_GROUP_MAX];
+};

src/openrct2/network/network.h

@@ -101,3 +101,5 @@ const utf8* network_get_server_provider_email();
 const utf8* network_get_server_provider_website();
 
 std::string network_get_version();
+
+NetworkStats_t network_get_stats();