mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-23 15:52:55 +01:00
Code Issues Releases Wiki Activity

Drop 'Network' prefix from more classes as suggested

Browse Source 
* Rename Network::NetworkReadPacket class to Network::ReadPacket
* Rename Network::NetworkKey class to Network::Key
* Rename Network::NetworkPacket class to Network::Packet
* Rename Network::NetworkUser class to Network::User
* Rename Network::NetworkConnection class to Network::Connection
This commit is contained in:
Aaron van Geffen
2025-09-05 13:17:14 +02:00
parent cecac8ee0b
commit d2c4a36787
19 changed files with 272 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
src/openrct2/network/NetworkBase.cpp
View File

@@ -265,7 +265,7 @@ namespace OpenRCT2::Network
_host = host; _host = host;
_port = port; _port = port;
_serverConnection = std::make_unique<NetworkConnection>(); _serverConnection = std::make_unique<Connection>();
_serverConnection->Socket = CreateTcpSocket(); _serverConnection->Socket = CreateTcpSocket();
_serverConnection->Socket->ConnectAsync(host, port); _serverConnection->Socket->ConnectAsync(host, port);
_serverState.gamestateSnapshotsEnabled = false; _serverState.gamestateSnapshotsEnabled = false;
@@ -394,7 +394,7 @@ namespace OpenRCT2::Network
if (GetMode() == Mode::server) if (GetMode() == Mode::server)
{ {
// Add SERVER to users.json and save. // Add SERVER to users.json and save.
NetworkUser* networkUser = _userManager.GetOrAddUser(player->KeyHash); User* networkUser = _userManager.GetOrAddUser(player->KeyHash);
networkUser->GroupId = player->Group; networkUser->GroupId = player->Group;
networkUser->Name = player->Name; networkUser->Name = player->Name;
_userManager.Save(); _userManager.Save();
@@ -449,7 +449,7 @@ namespace OpenRCT2::Network
return player_id; return player_id;
} }
NetworkConnection* NetworkBase::GetPlayerConnection(uint8_t id) const Connection* NetworkBase::GetPlayerConnection(uint8_t id) const
{ {
auto player = GetPlayerByID(id); auto player = GetPlayerByID(id);
if (player != nullptr) if (player != nullptr)
@@ -787,7 +787,7 @@ namespace OpenRCT2::Network
return formatted.c_str(); return formatted.c_str();
} }
void NetworkBase::SendPacketToClients(const NetworkPacket& packet, bool front, bool gameCmd) const void NetworkBase::SendPacketToClients(const Packet& packet, bool front, bool gameCmd) const
{ {
for (auto& client_connection : client_connection_list) for (auto& client_connection : client_connection_list)
{ {
@@ -987,7 +987,7 @@ namespace OpenRCT2::Network
uint8_t NetworkBase::GetGroupIDByHash(const std::string& keyhash) uint8_t NetworkBase::GetGroupIDByHash(const std::string& keyhash)
{ {
const NetworkUser* networkUser = _userManager.GetUserByHash(keyhash); const User* networkUser = _userManager.GetUserByHash(keyhash);
uint8_t groupId = GetDefaultGroup(); uint8_t groupId = GetDefaultGroup();
if (networkUser != nullptr && networkUser->GroupId.has_value()) if (networkUser != nullptr && networkUser->GroupId.has_value())
@@ -1255,7 +1255,7 @@ namespace OpenRCT2::Network
LOG_VERBOSE("Requesting gamestate from server for tick %u", tick); LOG_VERBOSE("Requesting gamestate from server for tick %u", tick);
NetworkPacket packet(Command::requestGameState); Packet packet(Command::requestGameState);
packet << tick; packet << tick;
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
@@ -1263,7 +1263,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_TOKEN() void NetworkBase::Client_Send_TOKEN()
{ {
LOG_VERBOSE("requesting token"); LOG_VERBOSE("requesting token");
NetworkPacket packet(Command::token); Packet packet(Command::token);
_serverConnection->AuthStatus = Auth::requested; _serverConnection->AuthStatus = Auth::requested;
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
@@ -1271,7 +1271,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_AUTH( void NetworkBase::Client_Send_AUTH(
const std::string& name, const std::string& password, const std::string& pubkey, const std::vector<uint8_t>& signature) const std::string& name, const std::string& password, const std::string& pubkey, const std::vector<uint8_t>& signature)
{ {
NetworkPacket packet(Command::auth); Packet packet(Command::auth);
packet.WriteString(GetVersion()); packet.WriteString(GetVersion());
packet.WriteString(name); packet.WriteString(name);
packet.WriteString(password); packet.WriteString(password);
@@ -1286,7 +1286,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects) void NetworkBase::Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects)
{ {
LOG_VERBOSE("client requests %u objects", uint32_t(objects.size())); LOG_VERBOSE("client requests %u objects", uint32_t(objects.size()));
NetworkPacket packet(Command::mapRequest); Packet packet(Command::mapRequest);
packet << static_cast<uint32_t>(objects.size()); packet << static_cast<uint32_t>(objects.size());
for (const auto& object : objects) for (const auto& object : objects)
{ {
@@ -1306,22 +1306,22 @@ namespace OpenRCT2::Network
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendToken(NetworkConnection& connection) void NetworkBase::ServerSendToken(Connection& connection)
{ {
NetworkPacket packet(Command::token); Packet packet(Command::token);
packet << static_cast<uint32_t>(connection.Challenge.size()); packet << static_cast<uint32_t>(connection.Challenge.size());
packet.Write(connection.Challenge.data(), connection.Challenge.size()); packet.Write(connection.Challenge.data(), connection.Challenge.size());
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendObjectsList( void NetworkBase::ServerSendObjectsList(
NetworkConnection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const Connection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const
{ {
LOG_VERBOSE("Server sends objects list with %u items", objects.size()); LOG_VERBOSE("Server sends objects list with %u items", objects.size());
if (objects.empty()) if (objects.empty())
{ {
NetworkPacket packet(Command::objectsList); Packet packet(Command::objectsList);
packet << static_cast<uint32_t>(0) << static_cast<uint32_t>(objects.size()); packet << static_cast<uint32_t>(0) << static_cast<uint32_t>(objects.size());
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
@@ -1332,7 +1332,7 @@ namespace OpenRCT2::Network
{ {
const auto* object = objects[i]; const auto* object = objects[i];
NetworkPacket packet(Command::objectsList); Packet packet(Command::objectsList);
packet << static_cast<uint32_t>(i) << static_cast<uint32_t>(objects.size()); packet << static_cast<uint32_t>(i) << static_cast<uint32_t>(objects.size());
if (object->Identifier.empty()) if (object->Identifier.empty())
@@ -1355,7 +1355,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerSendScripts(NetworkConnection& connection) void NetworkBase::ServerSendScripts(Connection& connection)
{ {
#ifdef ENABLE_SCRIPTING #ifdef ENABLE_SCRIPTING
using namespace OpenRCT2::Scripting; using namespace OpenRCT2::Scripting;
@@ -1378,7 +1378,7 @@ namespace OpenRCT2::Network
} }
// Send the header packet. // Send the header packet.
NetworkPacket packetScriptHeader(Command::scriptsHeader); Packet packetScriptHeader(Command::scriptsHeader);
packetScriptHeader << static_cast<uint32_t>(remotePlugins.size()); packetScriptHeader << static_cast<uint32_t>(remotePlugins.size());
packetScriptHeader << static_cast<uint32_t>(pluginData.GetLength()); packetScriptHeader << static_cast<uint32_t>(pluginData.GetLength());
connection.QueuePacket(std::move(packetScriptHeader)); connection.QueuePacket(std::move(packetScriptHeader));
@@ -1390,7 +1390,7 @@ namespace OpenRCT2::Network
{ {
const uint32_t chunkSize = std::min<uint32_t>(pluginData.GetLength() - dataOffset, kChunkSize); const uint32_t chunkSize = std::min<uint32_t>(pluginData.GetLength() - dataOffset, kChunkSize);
NetworkPacket packet(Command::scriptsData); Packet packet(Command::scriptsData);
packet << chunkSize; packet << chunkSize;
packet.Write(pluginDataBuffer + dataOffset, chunkSize); packet.Write(pluginDataBuffer + dataOffset, chunkSize);
@@ -1401,17 +1401,17 @@ namespace OpenRCT2::Network
Guard::Assert(dataOffset == pluginData.GetLength()); Guard::Assert(dataOffset == pluginData.GetLength());
#else #else
NetworkPacket packetScriptHeader(Command::scriptsHeader); Packet packetScriptHeader(Command::scriptsHeader);
packetScriptHeader << static_cast<uint32_t>(0u); packetScriptHeader << static_cast<uint32_t>(0u);
packetScriptHeader << static_cast<uint32_t>(0u); packetScriptHeader << static_cast<uint32_t>(0u);
#endif #endif
} }
void NetworkBase::Client_Send_HEARTBEAT(NetworkConnection& connection) const void NetworkBase::Client_Send_HEARTBEAT(Connection& connection) const
{ {
LOG_VERBOSE("Sending heartbeat"); LOG_VERBOSE("Sending heartbeat");
NetworkPacket packet(Command::heartbeat); Packet packet(Command::heartbeat);
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
} }
@@ -1436,14 +1436,14 @@ namespace OpenRCT2::Network
return stats; return stats;
} }
void NetworkBase::ServerSendAuth(NetworkConnection& connection) void NetworkBase::ServerSendAuth(Connection& connection)
{ {
uint8_t new_playerid = 0; uint8_t new_playerid = 0;
if (connection.player != nullptr) if (connection.player != nullptr)
{ {
new_playerid = connection.player->Id; new_playerid = connection.player->Id;
} }
NetworkPacket packet(Command::auth); Packet packet(Command::auth);
packet << static_cast<uint32_t>(connection.AuthStatus) << new_playerid; packet << static_cast<uint32_t>(connection.AuthStatus) << new_playerid;
if (connection.AuthStatus == Auth::badVersion) if (connection.AuthStatus == Auth::badVersion)
{ {
@@ -1456,7 +1456,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerSendMap(NetworkConnection* connection) void NetworkBase::ServerSendMap(Connection* connection)
{ {
std::vector<const ObjectRepositoryItem*> objects; std::vector<const ObjectRepositoryItem*> objects;
if (connection != nullptr) if (connection != nullptr)
@@ -1486,7 +1486,7 @@ namespace OpenRCT2::Network
for (size_t i = 0; i < header.size(); i += chunksize) for (size_t i = 0; i < header.size(); i += chunksize)
{ {
size_t datasize = std::min(chunksize, header.size() - i); size_t datasize = std::min(chunksize, header.size() - i);
NetworkPacket packet(Command::map); Packet packet(Command::map);
packet << static_cast<uint32_t>(header.size()) << static_cast<uint32_t>(i); packet << static_cast<uint32_t>(header.size()) << static_cast<uint32_t>(i);
packet.Write(&header[i], datasize); packet.Write(&header[i], datasize);
if (connection != nullptr) if (connection != nullptr)
@@ -1518,14 +1518,14 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_CHAT(const char* text) void NetworkBase::Client_Send_CHAT(const char* text)
{ {
NetworkPacket packet(Command::chat); Packet packet(Command::chat);
packet.WriteString(text); packet.WriteString(text);
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds) void NetworkBase::ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds)
{ {
NetworkPacket packet(Command::chat); Packet packet(Command::chat);
packet.WriteString(text); packet.WriteString(text);
if (playerIds.empty()) if (playerIds.empty())
@@ -1548,7 +1548,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_GAME_ACTION(const GameActions::GameAction* action) void NetworkBase::Client_Send_GAME_ACTION(const GameActions::GameAction* action)
{ {
NetworkPacket packet(Command::gameAction); Packet packet(Command::gameAction);
uint32_t networkId = 0; uint32_t networkId = 0;
networkId = ++_actionId; networkId = ++_actionId;
@@ -1569,7 +1569,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendGameAction(const GameActions::GameAction* action) void NetworkBase::ServerSendGameAction(const GameActions::GameAction* action)
{ {
NetworkPacket packet(Command::gameAction); Packet packet(Command::gameAction);
DataSerialiser stream(true); DataSerialiser stream(true);
action->Serialise(stream); action->Serialise(stream);
@@ -1581,7 +1581,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendTick() void NetworkBase::ServerSendTick()
{ {
NetworkPacket packet(Command::tick); Packet packet(Command::tick);
packet << getGameState().currentTicks << ScenarioRandState().s0; packet << getGameState().currentTicks << ScenarioRandState().s0;
uint32_t flags = 0; uint32_t flags = 0;
// Simple counter which limits how often a sprite checksum gets sent. // Simple counter which limits how often a sprite checksum gets sent.
@@ -1608,7 +1608,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPlayerInfo(int32_t playerId) void NetworkBase::ServerSendPlayerInfo(int32_t playerId)
{ {
NetworkPacket packet(Command::playerInfo); Packet packet(Command::playerInfo);
packet << getGameState().currentTicks; packet << getGameState().currentTicks;
auto* player = GetPlayerByID(playerId); auto* player = GetPlayerByID(playerId);
@@ -1621,7 +1621,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPlayerList() void NetworkBase::ServerSendPlayerList()
{ {
NetworkPacket packet(Command::playerList); Packet packet(Command::playerList);
packet << getGameState().currentTicks << static_cast<uint8_t>(player_list.size()); packet << getGameState().currentTicks << static_cast<uint8_t>(player_list.size());
for (auto& player : player_list) for (auto& player : player_list)
{ {
@@ -1632,14 +1632,14 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_PING() void NetworkBase::Client_Send_PING()
{ {
NetworkPacket packet(Command::ping); Packet packet(Command::ping);
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendPing() void NetworkBase::ServerSendPing()
{ {
last_ping_sent_time = Platform::GetTicks(); last_ping_sent_time = Platform::GetTicks();
NetworkPacket packet(Command::ping); Packet packet(Command::ping);
for (auto& client_connection : client_connection_list) for (auto& client_connection : client_connection_list)
{ {
client_connection->PingTime = Platform::GetTicks(); client_connection->PingTime = Platform::GetTicks();
@@ -1649,7 +1649,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPingList() void NetworkBase::ServerSendPingList()
{ {
NetworkPacket packet(Command::pingList); Packet packet(Command::pingList);
packet << static_cast<uint8_t>(player_list.size()); packet << static_cast<uint8_t>(player_list.size());
for (auto& player : player_list) for (auto& player : player_list)
{ {
@@ -1658,9 +1658,9 @@ namespace OpenRCT2::Network
SendPacketToClients(packet); SendPacketToClients(packet);
} }
void NetworkBase::ServerSendSetDisconnectMsg(NetworkConnection& connection, const char* msg) void NetworkBase::ServerSendSetDisconnectMsg(Connection& connection, const char* msg)
{ {
NetworkPacket packet(Command::disconnectMessage); Packet packet(Command::disconnectMessage);
packet.WriteString(msg); packet.WriteString(msg);
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
} }
@@ -1680,9 +1680,9 @@ namespace OpenRCT2::Network
return jsonObj; return jsonObj;
} }
void NetworkBase::ServerSendGameInfo(NetworkConnection& connection) void NetworkBase::ServerSendGameInfo(Connection& connection)
{ {
NetworkPacket packet(Command::gameInfo); Packet packet(Command::gameInfo);
#ifndef DISABLE_HTTP #ifndef DISABLE_HTTP
json_t jsonObj = GetServerInfoAsJson(); json_t jsonObj = GetServerInfoAsJson();
@@ -1703,16 +1703,16 @@ namespace OpenRCT2::Network
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendShowError(NetworkConnection& connection, StringId title, StringId message) void NetworkBase::ServerSendShowError(Connection& connection, StringId title, StringId message)
{ {
NetworkPacket packet(Command::showError); Packet packet(Command::showError);
packet << title << message; packet << title << message;
connection.QueuePacket(std::move(packet)); connection.QueuePacket(std::move(packet));
} }
void NetworkBase::ServerSendGroupList(NetworkConnection& connection) void NetworkBase::ServerSendGroupList(Connection& connection)
{ {
NetworkPacket packet(Command::groupList); Packet packet(Command::groupList);
packet << static_cast<uint8_t>(group_list.size()) << default_group; packet << static_cast<uint8_t>(group_list.size()) << default_group;
for (auto& group : group_list) for (auto& group : group_list)
{ {
@@ -1723,7 +1723,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendEventPlayerJoined(const char* playerName) void NetworkBase::ServerSendEventPlayerJoined(const char* playerName)
{ {
NetworkPacket packet(Command::event); Packet packet(Command::event);
packet << static_cast<uint16_t>(SERVER_EVENT_PLAYER_JOINED); packet << static_cast<uint16_t>(SERVER_EVENT_PLAYER_JOINED);
packet.WriteString(playerName); packet.WriteString(playerName);
SendPacketToClients(packet); SendPacketToClients(packet);
@@ -1731,32 +1731,32 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendEventPlayerDisconnected(const char* playerName, const char* reason) void NetworkBase::ServerSendEventPlayerDisconnected(const char* playerName, const char* reason)
{ {
NetworkPacket packet(Command::event); Packet packet(Command::event);
packet << static_cast<uint16_t>(SERVER_EVENT_PLAYER_DISCONNECTED); packet << static_cast<uint16_t>(SERVER_EVENT_PLAYER_DISCONNECTED);
packet.WriteString(playerName); packet.WriteString(playerName);
packet.WriteString(reason); packet.WriteString(reason);
SendPacketToClients(packet); SendPacketToClients(packet);
} }
bool NetworkBase::ProcessConnection(NetworkConnection& connection) bool NetworkBase::ProcessConnection(Connection& connection)
{ {
NetworkReadPacket packetStatus; ReadPacket packetStatus;
uint32_t countProcessed = 0; uint32_t countProcessed = 0;
do do
{ {
countProcessed++; countProcessed++;
packetStatus = connection.ReadPacket(); packetStatus = connection.readPacket();
switch (packetStatus) switch (packetStatus)
{ {
case NetworkReadPacket::disconnected: case ReadPacket::disconnected:
// closed connection or network error // closed connection or network error
if (!connection.GetLastDisconnectReason()) if (!connection.GetLastDisconnectReason())
{ {
connection.SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED); connection.SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
} }
return false; return false;
case NetworkReadPacket::success: case ReadPacket::success:
// done reading in packet // done reading in packet
ProcessPacket(connection, connection.InboundPacket); ProcessPacket(connection, connection.InboundPacket);
if (!connection.IsValid()) if (!connection.IsValid())
@@ -1764,14 +1764,14 @@ namespace OpenRCT2::Network
return false; return false;
} }
break; break;
case NetworkReadPacket::moreData: case ReadPacket::moreData:
// more data required to be read // more data required to be read
break; break;
case NetworkReadPacket::noData: case ReadPacket::noData:
// could not read anything from socket // could not read anything from socket
break; break;
} }
} while (packetStatus == NetworkReadPacket::success && countProcessed < kMaxPacketsPerUpdate); } while (packetStatus == ReadPacket::success && countProcessed < kMaxPacketsPerUpdate);
if (!connection.ReceivedPacketRecently()) if (!connection.ReceivedPacketRecently())
{ {
@@ -1785,7 +1785,7 @@ namespace OpenRCT2::Network
return true; return true;
} }
void NetworkBase::ProcessPacket(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ProcessPacket(Connection& connection, Packet& packet)
{ {
const auto& handlerList = GetMode() == Mode::server ? server_command_handlers : client_command_handlers; const auto& handlerList = GetMode() == Mode::server ? server_command_handlers : client_command_handlers;
@@ -1824,7 +1824,7 @@ namespace OpenRCT2::Network
} }
static bool ProcessPlayerAuthenticatePluginHooks( static bool ProcessPlayerAuthenticatePluginHooks(
const NetworkConnection& connection, std::string_view name, std::string_view publicKeyHash) const Connection& connection, std::string_view name, std::string_view publicKeyHash)
{ {
#ifdef ENABLE_SCRIPTING #ifdef ENABLE_SCRIPTING
using namespace OpenRCT2::Scripting; using namespace OpenRCT2::Scripting;
@@ -2039,13 +2039,13 @@ namespace OpenRCT2::Network
AppendServerLog(addr); AppendServerLog(addr);
// Store connection // Store connection
auto connection = std::make_unique<NetworkConnection>(); auto connection = std::make_unique<Connection>();
connection->Socket = std::move(socket); connection->Socket = std::move(socket);
client_connection_list.push_back(std::move(connection)); client_connection_list.push_back(std::move(connection));
} }
void NetworkBase::ServerClientDisconnected(std::unique_ptr<NetworkConnection>& connection) void NetworkBase::ServerClientDisconnected(std::unique_ptr<Connection>& connection)
{ {
Player* connection_player = connection->player; Player* connection_player = connection->player;
if (connection_player == nullptr) if (connection_player == nullptr)
@@ -2084,7 +2084,7 @@ namespace OpenRCT2::Network
ProcessPlayerLeftPluginHooks(connection_player->Id); ProcessPlayerLeftPluginHooks(connection_player->Id);
} }
void NetworkBase::RemovePlayer(std::unique_ptr<NetworkConnection>& connection) void NetworkBase::RemovePlayer(std::unique_ptr<Connection>& connection)
{ {
Player* connection_player = connection->player; Player* connection_player = connection->player;
if (connection_player == nullptr) if (connection_player == nullptr)
@@ -2132,7 +2132,7 @@ namespace OpenRCT2::Network
_userManager.Load(); _userManager.Load();
// Check if the key is registered // Check if the key is registered
const NetworkUser* networkUser = _userManager.GetUserByHash(keyhash); const User* networkUser = _userManager.GetUserByHash(keyhash);
player = std::make_unique<Player>(); player = std::make_unique<Player>();
player->Id = newid; player->Id = newid;
@@ -2208,7 +2208,7 @@ namespace OpenRCT2::Network
return new_name; return new_name;
} }
void NetworkBase::Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_TOKEN(Connection& connection, Packet& packet)
{ {
auto keyPath = GetPrivateKeyPath(Config::Get().network.PlayerName); auto keyPath = GetPrivateKeyPath(Config::Get().network.PlayerName);
if (!File::Exists(keyPath)) if (!File::Exists(keyPath))
@@ -2256,7 +2256,7 @@ namespace OpenRCT2::Network
Client_Send_AUTH(Config::Get().network.PlayerName, gCustomPassword, pubkey, signature); Client_Send_AUTH(Config::Get().network.PlayerName, gCustomPassword, pubkey, signature);
} }
void NetworkBase::ServerHandleRequestGamestate(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleRequestGamestate(Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
packet >> tick; packet >> tick;
@@ -2287,7 +2287,7 @@ namespace OpenRCT2::Network
dataSize = snapshotMemory.GetLength() - bytesSent; dataSize = snapshotMemory.GetLength() - bytesSent;
} }
NetworkPacket packetGameStateChunk(Command::gameState); Packet packetGameStateChunk(Command::gameState);
packetGameStateChunk << tick << length << bytesSent << dataSize; packetGameStateChunk << tick << length << bytesSent << dataSize;
packetGameStateChunk.Write(static_cast<const uint8_t*>(snapshotMemory.GetData()) + bytesSent, dataSize); packetGameStateChunk.Write(static_cast<const uint8_t*>(snapshotMemory.GetData()) + bytesSent, dataSize);
@@ -2298,13 +2298,13 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerHandleHeartbeat(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleHeartbeat(Connection& connection, Packet& packet)
{ {
LOG_VERBOSE("Client %s heartbeat", connection.Socket->GetHostName()); LOG_VERBOSE("Client %s heartbeat", connection.Socket->GetHostName());
connection.ResetLastPacketTime(); connection.ResetLastPacketTime();
} }
void NetworkBase::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_AUTH(Connection& connection, Packet& packet)
{ {
uint32_t auth_status; uint32_t auth_status;
packet >> auth_status >> const_cast<uint8_t&>(player_id); packet >> auth_status >> const_cast<uint8_t&>(player_id);
@@ -2352,7 +2352,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerClientJoined(std::string_view name, const std::string& keyhash, NetworkConnection& connection) void NetworkBase::ServerClientJoined(std::string_view name, const std::string& keyhash, Connection& connection)
{ {
auto player = AddPlayer(std::string(name), keyhash); auto player = AddPlayer(std::string(name), keyhash);
connection.player = player; connection.player = player;
@@ -2379,7 +2379,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerHandleToken(NetworkConnection& connection, [[maybe_unused]] NetworkPacket& packet) void NetworkBase::ServerHandleToken(Connection& connection, [[maybe_unused]] Packet& packet)
{ {
uint8_t token_size = 10 + (rand() & 0x7f); uint8_t token_size = 10 + (rand() & 0x7f);
connection.Challenge.resize(token_size); connection.Challenge.resize(token_size);
@@ -2399,7 +2399,7 @@ namespace OpenRCT2::Network
ContextOpenIntent(&intent); ContextOpenIntent(&intent);
} }
void NetworkBase::Client_Handle_OBJECTS_LIST(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_OBJECTS_LIST(Connection& connection, Packet& packet)
{ {
auto& repo = GetContext().GetObjectRepository(); auto& repo = GetContext().GetObjectRepository();
@@ -2468,7 +2468,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::Client_Handle_SCRIPTS_HEADER(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_SCRIPTS_HEADER(Connection& connection, Packet& packet)
{ {
uint32_t numScripts{}; uint32_t numScripts{};
uint32_t dataSize{}; uint32_t dataSize{};
@@ -2487,7 +2487,7 @@ namespace OpenRCT2::Network
#endif #endif
} }
void NetworkBase::Client_Handle_SCRIPTS_DATA(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_SCRIPTS_DATA(Connection& connection, Packet& packet)
{ {
#ifdef ENABLE_SCRIPTING #ifdef ENABLE_SCRIPTING
uint32_t dataSize{}; uint32_t dataSize{};
@@ -2524,7 +2524,7 @@ namespace OpenRCT2::Network
#endif #endif
} }
void NetworkBase::Client_Handle_GAMESTATE(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_GAMESTATE(Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
uint32_t totalSize; uint32_t totalSize;
@@ -2593,7 +2593,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerHandleMapRequest(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleMapRequest(Connection& connection, Packet& packet)
{ {
uint32_t size; uint32_t size;
packet >> size; packet >> size;
@@ -2636,7 +2636,7 @@ namespace OpenRCT2::Network
ServerSendGroupList(connection); ServerSendGroupList(connection);
} }
void NetworkBase::ServerHandleAuth(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleAuth(Connection& connection, Packet& packet)
{ {
if (connection.AuthStatus != Auth::ok) if (connection.AuthStatus != Auth::ok)
{ {
@@ -2676,13 +2676,13 @@ namespace OpenRCT2::Network
std::memcpy(signature.data(), signatureData, sigsize); std::memcpy(signature.data(), signatureData, sigsize);
auto ms = MemoryStream(pubkey.data(), pubkey.size()); auto ms = MemoryStream(pubkey.data(), pubkey.size());
if (!connection.Key.LoadPublic(&ms)) if (!connection.key.LoadPublic(&ms))
{ {
throw std::runtime_error("Failed to load public key."); throw std::runtime_error("Failed to load public key.");
} }
bool verified = connection.Key.Verify(connection.Challenge.data(), connection.Challenge.size(), signature); bool verified = connection.key.Verify(connection.Challenge.data(), connection.Challenge.size(), signature);
const std::string hash = connection.Key.PublicKeyHash(); const std::string hash = connection.key.PublicKeyHash();
if (verified) if (verified)
{ {
LOG_VERBOSE("Connection %s: Signature verification ok. Hash %s", hostName, hash.c_str()); LOG_VERBOSE("Connection %s: Signature verification ok. Hash %s", hostName, hash.c_str());
@@ -2712,7 +2712,7 @@ namespace OpenRCT2::Network
bool passwordless = false; bool passwordless = false;
if (connection.AuthStatus == Auth::verified) if (connection.AuthStatus == Auth::verified)
{ {
const NetworkGroup* group = GetGroupByID(GetGroupIDByHash(connection.Key.PublicKeyHash())); const NetworkGroup* group = GetGroupByID(GetGroupIDByHash(connection.key.PublicKeyHash()));
if (group != nullptr) if (group != nullptr)
{ {
passwordless = group->CanPerformAction(Permission::PasswordlessLogin); passwordless = group->CanPerformAction(Permission::PasswordlessLogin);
@@ -2749,7 +2749,7 @@ namespace OpenRCT2::Network
} }
else if (connection.AuthStatus == Auth::verified) else if (connection.AuthStatus == Auth::verified)
{ {
const std::string hash = connection.Key.PublicKeyHash(); const std::string hash = connection.key.PublicKeyHash();
if (ProcessPlayerAuthenticatePluginHooks(connection, name, hash)) if (ProcessPlayerAuthenticatePluginHooks(connection, name, hash))
{ {
connection.AuthStatus = Auth::ok; connection.AuthStatus = Auth::ok;
@@ -2766,7 +2766,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::Client_Handle_MAP([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_MAP([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint32_t size, offset; uint32_t size, offset;
packet >> size >> offset; packet >> size >> offset;
@@ -2896,7 +2896,7 @@ namespace OpenRCT2::Network
return result; return result;
} }
void NetworkBase::Client_Handle_CHAT([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_CHAT([[maybe_unused]] Connection& connection, Packet& packet)
{ {
auto text = packet.ReadString(); auto text = packet.ReadString();
if (!text.empty()) if (!text.empty())
@@ -2941,7 +2941,7 @@ namespace OpenRCT2::Network
return true; return true;
} }
void NetworkBase::ServerHandleChat(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleChat(Connection& connection, Packet& packet)
{ {
auto szText = packet.ReadString(); auto szText = packet.ReadString();
if (szText.empty()) if (szText.empty())
@@ -2971,7 +2971,7 @@ namespace OpenRCT2::Network
ServerSendChat(formatted); ServerSendChat(formatted);
} }
void NetworkBase::Client_Handle_GAME_ACTION([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_GAME_ACTION([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
GameCommand actionType; GameCommand actionType;
@@ -3007,7 +3007,7 @@ namespace OpenRCT2::Network
GameActions::Enqueue(std::move(action), tick); GameActions::Enqueue(std::move(action), tick);
} }
void NetworkBase::ServerHandleGameAction(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::ServerHandleGameAction(Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
GameCommand actionType; GameCommand actionType;
@@ -3079,7 +3079,7 @@ namespace OpenRCT2::Network
GameActions::Enqueue(std::move(ga), tick); GameActions::Enqueue(std::move(ga), tick);
} }
void NetworkBase::Client_Handle_TICK([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_TICK([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint32_t srand0; uint32_t srand0;
uint32_t flags; uint32_t flags;
@@ -3110,7 +3110,7 @@ namespace OpenRCT2::Network
_serverTickData.emplace(serverTick, tickData); _serverTickData.emplace(serverTick, tickData);
} }
void NetworkBase::Client_Handle_PLAYERINFO([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_PLAYERINFO([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
packet >> tick; packet >> tick;
@@ -3121,7 +3121,7 @@ namespace OpenRCT2::Network
_pendingPlayerInfo.emplace(tick, playerInfo); _pendingPlayerInfo.emplace(tick, playerInfo);
} }
void NetworkBase::Client_Handle_PLAYERLIST([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_PLAYERLIST([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint32_t tick; uint32_t tick;
uint8_t size; uint8_t size;
@@ -3139,12 +3139,12 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::Client_Handle_PING([[maybe_unused]] NetworkConnection& connection, [[maybe_unused]] NetworkPacket& packet) void NetworkBase::Client_Handle_PING([[maybe_unused]] Connection& connection, [[maybe_unused]] Packet& packet)
{ {
Client_Send_PING(); Client_Send_PING();
} }
void NetworkBase::ServerHandlePing(NetworkConnection& connection, [[maybe_unused]] NetworkPacket& packet) void NetworkBase::ServerHandlePing(Connection& connection, [[maybe_unused]] Packet& packet)
{ {
int32_t ping = Platform::GetTicks() - connection.PingTime; int32_t ping = Platform::GetTicks() - connection.PingTime;
if (ping < 0) if (ping < 0)
@@ -3159,7 +3159,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::Client_Handle_PINGLIST([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_PINGLIST([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint8_t size; uint8_t size;
packet >> size; packet >> size;
@@ -3179,7 +3179,7 @@ namespace OpenRCT2::Network
windowMgr->InvalidateByClass(WindowClass::Player); windowMgr->InvalidateByClass(WindowClass::Player);
} }
void NetworkBase::Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_SETDISCONNECTMSG(Connection& connection, Packet& packet)
{ {
auto disconnectmsg = packet.ReadString(); auto disconnectmsg = packet.ReadString();
if (!disconnectmsg.empty()) if (!disconnectmsg.empty())
@@ -3188,19 +3188,19 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::ServerHandleGameInfo(NetworkConnection& connection, [[maybe_unused]] NetworkPacket& packet) void NetworkBase::ServerHandleGameInfo(Connection& connection, [[maybe_unused]] Packet& packet)
{ {
ServerSendGameInfo(connection); ServerSendGameInfo(connection);
} }
void NetworkBase::Client_Handle_SHOWERROR([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_SHOWERROR([[maybe_unused]] Connection& connection, Packet& packet)
{ {
StringId title, message; StringId title, message;
packet >> title >> message; packet >> title >> message;
ContextShowError(title, message, {}); ContextShowError(title, message, {});
} }
void NetworkBase::Client_Handle_GROUPLIST([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_GROUPLIST([[maybe_unused]] Connection& connection, Packet& packet)
{ {
group_list.clear(); group_list.clear();
uint8_t size; uint8_t size;
@@ -3214,7 +3214,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkBase::Client_Handle_EVENT([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_EVENT([[maybe_unused]] Connection& connection, Packet& packet)
{ {
uint16_t eventType; uint16_t eventType;
packet >> eventType; packet >> eventType;
@@ -3249,11 +3249,11 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_GAMEINFO() void NetworkBase::Client_Send_GAMEINFO()
{ {
LOG_VERBOSE("requesting gameinfo"); LOG_VERBOSE("requesting gameinfo");
NetworkPacket packet(Command::gameInfo); Packet packet(Command::gameInfo);
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
void NetworkBase::Client_Handle_GAMEINFO([[maybe_unused]] NetworkConnection& connection, NetworkPacket& packet) void NetworkBase::Client_Handle_GAMEINFO([[maybe_unused]] Connection& connection, Packet& packet)
{ {
auto jsonString = packet.ReadString(); auto jsonString = packet.ReadString();
packet >> _serverState.gamestateSnapshotsEnabled; packet >> _serverState.gamestateSnapshotsEnabled;
@@ -3616,8 +3616,8 @@ namespace OpenRCT2::Network
if (GetMode() == Mode::server) if (GetMode() == Mode::server)
{ {
// Add or update saved user // Add or update saved user
NetworkUserManager& userManager = network._userManager; UserManager& userManager = network._userManager;
NetworkUser* networkUser = userManager.GetOrAddUser(player->KeyHash); User* networkUser = userManager.GetOrAddUser(player->KeyHash);
networkUser->GroupId = groupId; networkUser->GroupId = groupId;
networkUser->Name = player->Name; networkUser->Name = player->Name;
userManager.Save(); userManager.Save();
@@ -3804,7 +3804,7 @@ namespace OpenRCT2::Network
{ {
network.KickPlayer(playerId); network.KickPlayer(playerId);
NetworkUserManager& networkUserManager = network._userManager; UserManager& networkUserManager = network._userManager;
networkUserManager.Load(); networkUserManager.Load();
networkUserManager.RemoveUser(player->KeyHash); networkUserManager.RemoveUser(player->KeyHash);
networkUserManager.Save(); networkUserManager.Save();

101
src/openrct2/network/NetworkBase.h
View File

@@ -57,13 +57,13 @@ namespace OpenRCT2::Network
void CloseChatLog(); void CloseChatLog();
Stats GetStats() const; Stats GetStats() const;
json_t GetServerInfoAsJson() const; json_t GetServerInfoAsJson() const;
bool ProcessConnection(NetworkConnection& connection); bool ProcessConnection(Connection& connection);
void CloseConnection(); void CloseConnection();
Player* AddPlayer(const std::string& name, const std::string& keyhash); Player* AddPlayer(const std::string& name, const std::string& keyhash);
void ProcessPacket(NetworkConnection& connection, NetworkPacket& packet); void ProcessPacket(Connection& connection, Packet& packet);
public: // Server public: // Server
NetworkConnection* GetPlayerConnection(uint8_t id) const; Connection* GetPlayerConnection(uint8_t id) const;
void KickPlayer(int32_t playerId); void KickPlayer(int32_t playerId);
NetworkGroup* AddGroup(); NetworkGroup* AddGroup();
void LoadGroups(); void LoadGroups();
@@ -79,17 +79,17 @@ namespace OpenRCT2::Network
std::string GetMasterServerUrl(); std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey(); std::string GenerateAdvertiseKey();
void SetupDefaultGroups(); void SetupDefaultGroups();
void RemovePlayer(std::unique_ptr<NetworkConnection>& connection); void RemovePlayer(std::unique_ptr<Connection>& connection);
void UpdateServer(); void UpdateServer();
void ServerClientDisconnected(std::unique_ptr<NetworkConnection>& connection); void ServerClientDisconnected(std::unique_ptr<Connection>& connection);
bool SaveMap(IStream* stream, const std::vector<const ObjectRepositoryItem*>& objects) const; bool SaveMap(IStream* stream, const std::vector<const ObjectRepositoryItem*>& objects) const;
std::vector<uint8_t> SaveForNetwork(const std::vector<const ObjectRepositoryItem*>& objects) const; std::vector<uint8_t> SaveForNetwork(const std::vector<const ObjectRepositoryItem*>& objects) const;
std::string MakePlayerNameUnique(const std::string& name); std::string MakePlayerNameUnique(const std::string& name);
// Packet dispatchers. // Packet dispatchers.
void ServerSendAuth(NetworkConnection& connection); void ServerSendAuth(Connection& connection);
void ServerSendToken(NetworkConnection& connection); void ServerSendToken(Connection& connection);
void ServerSendMap(NetworkConnection* connection = nullptr); void ServerSendMap(Connection* connection = nullptr);
void ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds = {}); void ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void ServerSendGameAction(const GameActions::GameAction* action); void ServerSendGameAction(const GameActions::GameAction* action);
void ServerSendTick(); void ServerSendTick();
@@ -97,27 +97,26 @@ namespace OpenRCT2::Network
void ServerSendPlayerList(); void ServerSendPlayerList();
void ServerSendPing(); void ServerSendPing();
void ServerSendPingList(); void ServerSendPingList();
void ServerSendSetDisconnectMsg(NetworkConnection& connection, const char* msg); void ServerSendSetDisconnectMsg(Connection& connection, const char* msg);
void ServerSendGameInfo(NetworkConnection& connection); void ServerSendGameInfo(Connection& connection);
void ServerSendShowError(NetworkConnection& connection, StringId title, StringId message); void ServerSendShowError(Connection& connection, StringId title, StringId message);
void ServerSendGroupList(NetworkConnection& connection); void ServerSendGroupList(Connection& connection);
void ServerSendEventPlayerJoined(const char* playerName); void ServerSendEventPlayerJoined(const char* playerName);
void ServerSendEventPlayerDisconnected(const char* playerName, const char* reason); void ServerSendEventPlayerDisconnected(const char* playerName, const char* reason);
void ServerSendObjectsList( void ServerSendObjectsList(Connection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const;
NetworkConnection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const; void ServerSendScripts(Connection& connection);
void ServerSendScripts(NetworkConnection& connection);
// Handlers // Handlers
void ServerHandleRequestGamestate(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleRequestGamestate(Connection& connection, Packet& packet);
void ServerHandleHeartbeat(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleHeartbeat(Connection& connection, Packet& packet);
void ServerHandleAuth(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleAuth(Connection& connection, Packet& packet);
void ServerClientJoined(std::string_view name, const std::string& keyhash, NetworkConnection& connection); void ServerClientJoined(std::string_view name, const std::string& keyhash, Connection& connection);
void ServerHandleChat(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleChat(Connection& connection, Packet& packet);
void ServerHandleGameAction(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleGameAction(Connection& connection, Packet& packet);
void ServerHandlePing(NetworkConnection& connection, NetworkPacket& packet); void ServerHandlePing(Connection& connection, Packet& packet);
void ServerHandleGameInfo(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleGameInfo(Connection& connection, Packet& packet);
void ServerHandleToken(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleToken(Connection& connection, Packet& packet);
void ServerHandleMapRequest(NetworkConnection& connection, NetworkPacket& packet); void ServerHandleMapRequest(Connection& connection, Packet& packet);
public: // Client public: // Client
void Reconnect(); void Reconnect();
@@ -128,7 +127,7 @@ namespace OpenRCT2::Network
void ProcessPlayerInfo(); void ProcessPlayerInfo();
void ProcessDisconnectedClients(); void ProcessDisconnectedClients();
static const char* FormatChat(Player* fromplayer, const char* text); static const char* FormatChat(Player* fromplayer, const char* text);
void SendPacketToClients(const NetworkPacket& packet, bool front = false, bool gameCmd = false) const; void SendPacketToClients(const Packet& packet, bool front = false, bool gameCmd = false) const;
bool CheckSRAND(uint32_t tick, uint32_t srand0); bool CheckSRAND(uint32_t tick, uint32_t srand0);
bool CheckDesynchronizaton(); bool CheckDesynchronizaton();
void RequestStateSnapshot(); void RequestStateSnapshot();
@@ -149,33 +148,33 @@ namespace OpenRCT2::Network
void Client_Send_PING(); void Client_Send_PING();
void Client_Send_GAMEINFO(); void Client_Send_GAMEINFO();
void Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects); void Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects);
void Client_Send_HEARTBEAT(NetworkConnection& connection) const; void Client_Send_HEARTBEAT(Connection& connection) const;
// Handlers. // Handlers.
void Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_AUTH(Connection& connection, Packet& packet);
void Client_Handle_MAP(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_MAP(Connection& connection, Packet& packet);
void Client_Handle_CHAT(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_CHAT(Connection& connection, Packet& packet);
void Client_Handle_GAME_ACTION(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_GAME_ACTION(Connection& connection, Packet& packet);
void Client_Handle_TICK(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_TICK(Connection& connection, Packet& packet);
void Client_Handle_PLAYERINFO(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_PLAYERINFO(Connection& connection, Packet& packet);
void Client_Handle_PLAYERLIST(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_PLAYERLIST(Connection& connection, Packet& packet);
void Client_Handle_PING(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_PING(Connection& connection, Packet& packet);
void Client_Handle_PINGLIST(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_PINGLIST(Connection& connection, Packet& packet);
void Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_SETDISCONNECTMSG(Connection& connection, Packet& packet);
void Client_Handle_GAMEINFO(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_GAMEINFO(Connection& connection, Packet& packet);
void Client_Handle_SHOWERROR(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_SHOWERROR(Connection& connection, Packet& packet);
void Client_Handle_GROUPLIST(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_GROUPLIST(Connection& connection, Packet& packet);
void Client_Handle_EVENT(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_EVENT(Connection& connection, Packet& packet);
void Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_TOKEN(Connection& connection, Packet& packet);
void Client_Handle_OBJECTS_LIST(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_OBJECTS_LIST(Connection& connection, Packet& packet);
void Client_Handle_SCRIPTS_HEADER(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_SCRIPTS_HEADER(Connection& connection, Packet& packet);
void Client_Handle_SCRIPTS_DATA(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_SCRIPTS_DATA(Connection& connection, Packet& packet);
void Client_Handle_GAMESTATE(NetworkConnection& connection, NetworkPacket& packet); void Client_Handle_GAMESTATE(Connection& connection, Packet& packet);
std::vector<uint8_t> _challenge; std::vector<uint8_t> _challenge;
std::map<uint32_t, GameActions::GameAction::Callback_t> _gameActionCallbacks; std::map<uint32_t, GameActions::GameAction::Callback_t> _gameActionCallbacks;
NetworkKey _key; Key _key;
NetworkUserManager _userManager; UserManager _userManager;
public: // Public common public: // Public common
std::string ServerName; std::string ServerName;
@@ -189,7 +188,7 @@ namespace OpenRCT2::Network
bool IsServerPlayerInvisible = false; bool IsServerPlayerInvisible = false;
private: // Common Data private: // Common Data
using CommandHandler = void (NetworkBase::*)(NetworkConnection& connection, NetworkPacket& packet); using CommandHandler = void (NetworkBase::*)(Connection& connection, Packet& packet);
std::vector<uint8_t> chunk_buffer; std::vector<uint8_t> chunk_buffer;
std::ofstream _chat_log_fs; std::ofstream _chat_log_fs;
@@ -204,7 +203,7 @@ namespace OpenRCT2::Network
std::unordered_map<Command, CommandHandler> server_command_handlers; std::unordered_map<Command, CommandHandler> server_command_handlers;
std::unique_ptr<ITcpSocket> _listenSocket; std::unique_ptr<ITcpSocket> _listenSocket;
std::unique_ptr<INetworkServerAdvertiser> _advertiser; std::unique_ptr<INetworkServerAdvertiser> _advertiser;
std::list<std::unique_ptr<NetworkConnection>> client_connection_list; std::list<std::unique_ptr<Connection>> client_connection_list;
std::string _serverLogPath; std::string _serverLogPath;
std::string _serverLogFilenameFormat = "%Y%m%d-%H%M%S.txt"; std::string _serverLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::ofstream _server_log_fs; std::ofstream _server_log_fs;
@@ -232,7 +231,7 @@ namespace OpenRCT2::Network
}; };
std::unordered_map<Command, CommandHandler> client_command_handlers; std::unordered_map<Command, CommandHandler> client_command_handlers;
std::unique_ptr<NetworkConnection> _serverConnection; std::unique_ptr<Connection> _serverConnection;
std::map<uint32_t, PlayerListUpdate> _pendingPlayerLists; std::map<uint32_t, PlayerListUpdate> _pendingPlayerLists;
std::multimap<uint32_t, Player> _pendingPlayerInfo; std::multimap<uint32_t, Player> _pendingPlayerInfo;
std::map<uint32_t, ServerTickData> _serverTickData; std::map<uint32_t, ServerTickData> _serverTickData;

40
src/openrct2/network/NetworkConnection.cpp
View File

@@ -29,12 +29,12 @@ namespace OpenRCT2::Network
static_assert(kBufferSize <= std::numeric_limits<uint16_t>::max(), "kBufferSize too big, uint16_t is max."); static_assert(kBufferSize <= std::numeric_limits<uint16_t>::max(), "kBufferSize too big, uint16_t is max.");
NetworkConnection::NetworkConnection() noexcept Connection::Connection() noexcept
{ {
ResetLastPacketTime(); ResetLastPacketTime();
} }
NetworkReadPacket NetworkConnection::ReadPacket() ReadPacket Connection::readPacket()
{ {
size_t bytesRead = 0; size_t bytesRead = 0;
@@ -46,8 +46,8 @@ namespace OpenRCT2::Network
uint8_t* buffer = reinterpret_cast<uint8_t*>(&InboundPacket.Header); uint8_t* buffer = reinterpret_cast<uint8_t*>(&InboundPacket.Header);
NetworkReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead); ReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead);
if (status != NetworkReadPacket::success) if (status != ReadPacket::success)
{ {
return status; return status;
} }
@@ -56,7 +56,7 @@ namespace OpenRCT2::Network
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header)) if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
{ {
// If still not enough data for header, keep waiting. // If still not enough data for header, keep waiting.
return NetworkReadPacket::moreData; return ReadPacket::moreData;
} }
// Normalise values. // Normalise values.
@@ -79,8 +79,8 @@ namespace OpenRCT2::Network
if (missingLength > 0) if (missingLength > 0)
{ {
NetworkReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kBufferSize), &bytesRead); ReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kBufferSize), &bytesRead);
if (status != NetworkReadPacket::success) if (status != ReadPacket::success)
{ {
return status; return status;
} }
@@ -96,14 +96,14 @@ namespace OpenRCT2::Network
RecordPacketStats(InboundPacket, false); RecordPacketStats(InboundPacket, false);
return NetworkReadPacket::success; return ReadPacket::success;
} }
} }
return NetworkReadPacket::moreData; return ReadPacket::moreData;
} }
static sfl::small_vector<uint8_t, 512> serializePacket(const NetworkPacket& packet) static sfl::small_vector<uint8_t, 512> serializePacket(const Packet& packet)
{ {
// NOTE: For compatibility reasons for the master server we need to add sizeof(Header.Id) to the size. // NOTE: For compatibility reasons for the master server we need to add sizeof(Header.Id) to the size.
// Previously the Id field was not part of the header rather part of the body. // Previously the Id field was not part of the header rather part of the body.
@@ -125,7 +125,7 @@ namespace OpenRCT2::Network
return buffer; return buffer;
} }
void NetworkConnection::QueuePacket(const NetworkPacket& packet, bool front) void Connection::QueuePacket(const Packet& packet, bool front)
{ {
if (AuthStatus == Auth::ok || !packet.CommandRequiresAuth()) if (AuthStatus == Auth::ok || !packet.CommandRequiresAuth())
{ {
@@ -143,17 +143,17 @@ namespace OpenRCT2::Network
} }
} }
void NetworkConnection::Disconnect() noexcept void Connection::Disconnect() noexcept
{ {
ShouldDisconnect = true; ShouldDisconnect = true;
} }
bool NetworkConnection::IsValid() const bool Connection::IsValid() const
{ {
return !ShouldDisconnect && Socket->GetStatus() == SocketStatus::connected; return !ShouldDisconnect && Socket->GetStatus() == SocketStatus::connected;
} }
void NetworkConnection::SendQueuedData() void Connection::SendQueuedData()
{ {
if (_outboundBuffer.empty()) if (_outboundBuffer.empty())
{ {
@@ -168,12 +168,12 @@ namespace OpenRCT2::Network
} }
} }
void NetworkConnection::ResetLastPacketTime() noexcept void Connection::ResetLastPacketTime() noexcept
{ {
_lastPacketTime = Platform::GetTicks(); _lastPacketTime = Platform::GetTicks();
} }
bool NetworkConnection::ReceivedPacketRecently() const noexcept bool Connection::ReceivedPacketRecently() const noexcept
{ {
#ifndef DEBUG #ifndef DEBUG
constexpr auto kTimeoutMs = kNoDataTimeout * 1000; constexpr auto kTimeoutMs = kNoDataTimeout * 1000;
@@ -185,24 +185,24 @@ namespace OpenRCT2::Network
return true; return true;
} }
const utf8* NetworkConnection::GetLastDisconnectReason() const noexcept const utf8* Connection::GetLastDisconnectReason() const noexcept
{ {
return this->_lastDisconnectReason.c_str(); return this->_lastDisconnectReason.c_str();
} }
void NetworkConnection::SetLastDisconnectReason(std::string_view src) void Connection::SetLastDisconnectReason(std::string_view src)
{ {
_lastDisconnectReason = src; _lastDisconnectReason = src;
} }
void NetworkConnection::SetLastDisconnectReason(const StringId string_id, void* args) void Connection::SetLastDisconnectReason(const StringId string_id, void* args)
{ {
char buffer[kDisconnectReasonBufSize]; char buffer[kDisconnectReasonBufSize];
FormatStringLegacy(buffer, kDisconnectReasonBufSize, string_id, args); FormatStringLegacy(buffer, kDisconnectReasonBufSize, string_id, args);
SetLastDisconnectReason(buffer); SetLastDisconnectReason(buffer);
} }
void NetworkConnection::RecordPacketStats(const NetworkPacket& packet, bool sending) void Connection::RecordPacketStats(const Packet& packet, bool sending)
{ {
uint32_t packetSize = static_cast<uint32_t>(packet.BytesTransferred); uint32_t packetSize = static_cast<uint32_t>(packet.BytesTransferred);
StatisticsGroup trafficGroup; StatisticsGroup trafficGroup;

14
src/openrct2/network/NetworkConnection.h
View File

@@ -29,24 +29,24 @@ namespace OpenRCT2::Network
{ {
class Player; class Player;
class NetworkConnection final class Connection final
{ {
public: public:
std::unique_ptr<ITcpSocket> Socket = nullptr; std::unique_ptr<ITcpSocket> Socket = nullptr;
NetworkPacket InboundPacket; Packet InboundPacket;
Auth AuthStatus = Auth::none; Auth AuthStatus = Auth::none;
Stats stats = {}; Stats stats = {};
Player* player = nullptr; Player* player = nullptr;
uint32_t PingTime = 0; uint32_t PingTime = 0;
NetworkKey Key; Key key;
std::vector<uint8_t> Challenge; std::vector<uint8_t> Challenge;
std::vector<const ObjectRepositoryItem*> RequestedObjects; std::vector<const ObjectRepositoryItem*> RequestedObjects;
bool ShouldDisconnect = false; bool ShouldDisconnect = false;
NetworkConnection() noexcept; Connection() noexcept;
NetworkReadPacket ReadPacket(); ReadPacket readPacket();
void QueuePacket(const NetworkPacket& packet, bool front = false); void QueuePacket(const Packet& packet, bool front = false);
// This will not immediately disconnect the client. The disconnect // This will not immediately disconnect the client. The disconnect
// will happen post-tick. // will happen post-tick.
@@ -66,7 +66,7 @@ namespace OpenRCT2::Network
uint32_t _lastPacketTime = 0; uint32_t _lastPacketTime = 0;
std::string _lastDisconnectReason; std::string _lastDisconnectReason;
void RecordPacketStats(const NetworkPacket& packet, bool sending); void RecordPacketStats(const Packet& packet, bool sending);
}; };
} // namespace OpenRCT2::Network } // namespace OpenRCT2::Network

4
src/openrct2/network/NetworkGroup.cpp
View File

@@ -76,7 +76,7 @@ namespace OpenRCT2::Network
_name = name; _name = name;
} }
void NetworkGroup::Read(NetworkPacket& packet) void NetworkGroup::Read(Packet& packet)
{ {
packet >> Id; packet >> Id;
SetName(packet.ReadString()); SetName(packet.ReadString());
@@ -86,7 +86,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkGroup::Write(NetworkPacket& packet) const void NetworkGroup::Write(Packet& packet) const
{ {
packet << Id; packet << Id;
packet.WriteString(GetName().c_str()); packet.WriteString(GetName().c_str());

4
src/openrct2/network/NetworkGroup.h
View File

@@ -38,8 +38,8 @@ namespace OpenRCT2::Network
const std::string& GetName() const noexcept; const std::string& GetName() const noexcept;
void SetName(std::string_view name); void SetName(std::string_view name);
void Read(NetworkPacket& packet); void Read(Packet& packet);
void Write(NetworkPacket& packet) const; void Write(Packet& packet) const;
void ToggleActionPermission(Permission index); void ToggleActionPermission(Permission index);
bool CanPerformAction(Permission index) const noexcept; bool CanPerformAction(Permission index) const noexcept;
bool CanPerformCommand(GameCommand command) const; bool CanPerformCommand(GameCommand command) const;

40
src/openrct2/network/NetworkKey.cpp
View File

@@ -21,15 +21,15 @@
namespace OpenRCT2::Network namespace OpenRCT2::Network
{ {
NetworkKey::NetworkKey() = default; Key::Key() = default;
NetworkKey::~NetworkKey() = default; Key::~Key() = default;
void NetworkKey::Unload() void Key::Unload()
{ {
_key = nullptr; _key = nullptr;
} }
bool NetworkKey::Generate() bool Key::Generate()
{ {
try try
{ {
@@ -39,12 +39,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::Generate failed: %s", e.what()); LOG_ERROR("Network::Key::Generate failed: %s", e.what());
return false; return false;
} }
} }
bool NetworkKey::LoadPrivate(IStream* stream) bool Key::LoadPrivate(IStream* stream)
{ {
Guard::ArgumentNotNull(stream); Guard::ArgumentNotNull(stream);
@@ -71,12 +71,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::LoadPrivate failed: %s", e.what()); LOG_ERROR("Network::Key::LoadPrivate failed: %s", e.what());
return false; return false;
} }
} }
bool NetworkKey::LoadPublic(IStream* stream) bool Key::LoadPublic(IStream* stream)
{ {
Guard::ArgumentNotNull(stream); Guard::ArgumentNotNull(stream);
@@ -103,12 +103,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::LoadPublic failed: %s", e.what()); LOG_ERROR("Network::Key::LoadPublic failed: %s", e.what());
return false; return false;
} }
} }
bool NetworkKey::SavePrivate(IStream* stream) bool Key::SavePrivate(IStream* stream)
{ {
try try
{ {
@@ -122,12 +122,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::SavePrivate failed: %s", e.what()); LOG_ERROR("Network::Key::SavePrivate failed: %s", e.what());
return false; return false;
} }
} }
bool NetworkKey::SavePublic(IStream* stream) bool Key::SavePublic(IStream* stream)
{ {
try try
{ {
@@ -141,12 +141,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::SavePublic failed: %s", e.what()); LOG_ERROR("Network::Key::SavePublic failed: %s", e.what());
return false; return false;
} }
} }
std::string NetworkKey::PublicKeyString() std::string Key::PublicKeyString()
{ {
if (_key == nullptr) if (_key == nullptr)
{ {
@@ -156,7 +156,7 @@ namespace OpenRCT2::Network
} }
/** /**
* @brief NetworkKey::PublicKeyHash * @brief Key::PublicKeyHash
* Computes a short, human-readable (e.g. asciif-ied hex) hash for a given * Computes a short, human-readable (e.g. asciif-ied hex) hash for a given
* public key. Serves a purpose of easy identification keys in multiplayer * public key. Serves a purpose of easy identification keys in multiplayer
* overview, multiplayer settings. * overview, multiplayer settings.
@@ -166,7 +166,7 @@ namespace OpenRCT2::Network
* *
* @return returns a string containing key hash. * @return returns a string containing key hash.
*/ */
std::string NetworkKey::PublicKeyHash() std::string Key::PublicKeyHash()
{ {
try try
{ {
@@ -185,7 +185,7 @@ namespace OpenRCT2::Network
return nullptr; return nullptr;
} }
bool NetworkKey::Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const bool Key::Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const
{ {
try try
{ {
@@ -195,12 +195,12 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::Sign failed: %s", e.what()); LOG_ERROR("Network::Key::Sign failed: %s", e.what());
return false; return false;
} }
} }
bool NetworkKey::Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const bool Key::Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const
{ {
try try
{ {
@@ -209,7 +209,7 @@ namespace OpenRCT2::Network
} }
catch (const std::exception& e) catch (const std::exception& e)
{ {
LOG_ERROR("NetworkKey::Verify failed: %s", e.what()); LOG_ERROR("Network::Key::Verify failed: %s", e.what());
return false; return false;
} }
} }

8
src/openrct2/network/NetworkKey.h
View File

@@ -27,11 +27,11 @@ namespace OpenRCT2::Crypt
namespace OpenRCT2::Network namespace OpenRCT2::Network
{ {
class NetworkKey final class Key final
{ {
public: public:
NetworkKey(); Key();
~NetworkKey(); ~Key();
bool Generate(); bool Generate();
bool LoadPrivate(IStream* stream); bool LoadPrivate(IStream* stream);
bool LoadPublic(IStream* stream); bool LoadPublic(IStream* stream);
@@ -44,7 +44,7 @@ namespace OpenRCT2::Network
bool Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const; bool Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const;
private: private:
NetworkKey(const NetworkKey&) = delete; Key(const Key&) = delete;
std::unique_ptr<Crypt::RsaKey> _key; std::unique_ptr<Crypt::RsaKey> _key;
}; };
} // namespace OpenRCT2::Network } // namespace OpenRCT2::Network

20
src/openrct2/network/NetworkPacket.cpp
View File

@@ -17,34 +17,34 @@
namespace OpenRCT2::Network namespace OpenRCT2::Network
{ {
NetworkPacket::NetworkPacket(Command id) noexcept Packet::Packet(Command id) noexcept
: Header{ 0, id } : Header{ 0, id }
{ {
} }
uint8_t* NetworkPacket::GetData() noexcept uint8_t* Packet::GetData() noexcept
{ {
return Data.data(); return Data.data();
} }
const uint8_t* NetworkPacket::GetData() const noexcept const uint8_t* Packet::GetData() const noexcept
{ {
return Data.data(); return Data.data();
} }
Command NetworkPacket::GetCommand() const noexcept Command Packet::GetCommand() const noexcept
{ {
return Header.Id; return Header.Id;
} }
void NetworkPacket::Clear() noexcept void Packet::Clear() noexcept
{ {
BytesTransferred = 0; BytesTransferred = 0;
BytesRead = 0; BytesRead = 0;
Data.clear(); Data.clear();
} }
bool NetworkPacket::CommandRequiresAuth() const noexcept bool Packet::CommandRequiresAuth() const noexcept
{ {
switch (GetCommand()) switch (GetCommand())
{ {
@@ -63,19 +63,19 @@ namespace OpenRCT2::Network
} }
} }
void NetworkPacket::Write(const void* bytes, size_t size) void Packet::Write(const void* bytes, size_t size)
{ {
const uint8_t* src = reinterpret_cast<const uint8_t*>(bytes); const uint8_t* src = reinterpret_cast<const uint8_t*>(bytes);
Data.insert(Data.end(), src, src + size); Data.insert(Data.end(), src, src + size);
} }
void NetworkPacket::WriteString(std::string_view s) void Packet::WriteString(std::string_view s)
{ {
Write(s.data(), s.size()); Write(s.data(), s.size());
Data.push_back(0); Data.push_back(0);
} }
const uint8_t* NetworkPacket::Read(size_t size) const uint8_t* Packet::Read(size_t size)
{ {
if (BytesRead + size > Data.size()) if (BytesRead + size > Data.size())
{ {
@@ -87,7 +87,7 @@ namespace OpenRCT2::Network
return data; return data;
} }
std::string_view NetworkPacket::ReadString() std::string_view Packet::ReadString()
{ {
if (BytesRead >= Data.size()) if (BytesRead >= Data.size())
return {}; return {};

12
src/openrct2/network/NetworkPacket.h
View File

@@ -27,10 +27,10 @@ namespace OpenRCT2::Network
static_assert(sizeof(PacketHeader) == 6); static_assert(sizeof(PacketHeader) == 6);
#pragma pack(pop) #pragma pack(pop)
struct NetworkPacket final struct Packet final
{ {
NetworkPacket() noexcept = default; Packet() noexcept = default;
NetworkPacket(Command id) noexcept; Packet(Command id) noexcept;
uint8_t* GetData() noexcept; uint8_t* GetData() noexcept;
const uint8_t* GetData() const noexcept; const uint8_t* GetData() const noexcept;
@@ -47,7 +47,7 @@ namespace OpenRCT2::Network
void WriteString(std::string_view s); void WriteString(std::string_view s);
template<typename T> template<typename T>
NetworkPacket& operator>>(T& value) Packet& operator>>(T& value)
{ {
if (BytesRead + sizeof(value) > Header.Size) if (BytesRead + sizeof(value) > Header.Size)
{ {
@@ -64,14 +64,14 @@ namespace OpenRCT2::Network
} }
template<typename T> template<typename T>
NetworkPacket& operator<<(T value) Packet& operator<<(T value)
{ {
T swapped = ByteSwapBE(value); T swapped = ByteSwapBE(value);
Write(&swapped, sizeof(T)); Write(&swapped, sizeof(T));
return *this; return *this;
} }
NetworkPacket& operator<<(DataSerialiser& data) Packet& operator<<(DataSerialiser& data)
{ {
Write(static_cast<const uint8_t*>(data.GetStream().GetData()), data.GetStream().GetLength()); Write(static_cast<const uint8_t*>(data.GetStream().GetData()), data.GetStream().GetLength());
return *this; return *this;

4
src/openrct2/network/NetworkPlayer.cpp
View File

@@ -23,7 +23,7 @@ namespace OpenRCT2::Network
Name = name.substr(0, 36); Name = name.substr(0, 36);
} }
void Player::Read(NetworkPacket& packet) void Player::Read(Packet& packet)
{ {
auto name = packet.ReadString(); auto name = packet.ReadString();
SetName(name); SetName(name);
@@ -31,7 +31,7 @@ namespace OpenRCT2::Network
>> MoneySpent >> CommandsRan; >> MoneySpent >> CommandsRan;
} }
void Player::Write(NetworkPacket& packet) void Player::Write(Packet& packet)
{ {
packet.WriteString(Name); packet.WriteString(Name);
packet << Id << Flags << Group << LastAction << LastActionCoord.x << LastActionCoord.y << LastActionCoord.z packet << Id << Flags << Group << LastAction << LastActionCoord.x << LastActionCoord.y << LastActionCoord.z

6
src/openrct2/network/NetworkPlayer.h
View File

@@ -21,7 +21,7 @@ struct Peep;
namespace OpenRCT2::Network namespace OpenRCT2::Network
{ {
struct NetworkPacket; struct Packet;
class Player final class Player final
{ {
@@ -46,8 +46,8 @@ namespace OpenRCT2::Network
void SetName(std::string_view name); void SetName(std::string_view name);
void Read(NetworkPacket& packet); void Read(Packet& packet);
void Write(NetworkPacket& packet); void Write(Packet& packet);
void IncrementNumCommands(); void IncrementNumCommands();
void AddMoneySpent(money64 cost); void AddMoneySpent(money64 cost);
}; };

2
src/openrct2/network/NetworkServerAdvertiser.cpp
View File

@@ -116,7 +116,7 @@ namespace OpenRCT2::Network
size_t recievedBytes{}; size_t recievedBytes{};
std::unique_ptr<INetworkEndpoint> endpoint; std::unique_ptr<INetworkEndpoint> endpoint;
auto p = _lanListener->ReceiveData(buffer, sizeof(buffer) - 1, &recievedBytes, &endpoint); auto p = _lanListener->ReceiveData(buffer, sizeof(buffer) - 1, &recievedBytes, &endpoint);
if (p == NetworkReadPacket::success) if (p == ReadPacket::success)
{ {
std::string sender = endpoint->GetHostname(); std::string sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes from %s on LAN broadcast port", recievedBytes, sender.c_str()); LOG_VERBOSE("Received %zu bytes from %s on LAN broadcast port", recievedBytes, sender.c_str());

40
src/openrct2/network/NetworkUser.cpp
View File

@@ -26,18 +26,18 @@ namespace OpenRCT2::Network
{ {
constexpr const utf8* kUserStoreFilename = "users.json"; constexpr const utf8* kUserStoreFilename = "users.json";
std::unique_ptr<NetworkUser> NetworkUser::FromJson(const json_t& jsonData) std::unique_ptr<User> User::FromJson(const json_t& jsonData)
{ {
Guard::Assert(jsonData.is_object(), "NetworkUser::FromJson expects parameter jsonData to be object"); Guard::Assert(jsonData.is_object(), "Network::User::FromJson expects parameter jsonData to be object");
const std::string hash = Json::GetString(jsonData["hash"]); const std::string hash = Json::GetString(jsonData["hash"]);
const std::string name = Json::GetString(jsonData["name"]); const std::string name = Json::GetString(jsonData["name"]);
json_t jsonGroupId = jsonData["groupId"]; json_t jsonGroupId = jsonData["groupId"];
std::unique_ptr<NetworkUser> user = nullptr; std::unique_ptr<User> user = nullptr;
if (!hash.empty() && !name.empty()) if (!hash.empty() && !name.empty())
{ {
user = std::make_unique<NetworkUser>(); user = std::make_unique<User>();
user->Hash = hash; user->Hash = hash;
user->Name = name; user->Name = name;
if (jsonGroupId.is_number_integer()) if (jsonGroupId.is_number_integer())
@@ -49,7 +49,7 @@ namespace OpenRCT2::Network
return user; return user;
} }
json_t NetworkUser::ToJson() const json_t User::ToJson() const
{ {
json_t jsonData; json_t jsonData;
jsonData["hash"] = Hash; jsonData["hash"] = Hash;
@@ -65,7 +65,7 @@ namespace OpenRCT2::Network
return jsonData; return jsonData;
} }
void NetworkUserManager::Load() void UserManager::Load()
{ {
const auto path = GetStorePath(); const auto path = GetStorePath();
@@ -80,7 +80,7 @@ namespace OpenRCT2::Network
{ {
if (jsonUser.is_object()) if (jsonUser.is_object())
{ {
auto networkUser = NetworkUser::FromJson(jsonUser); auto networkUser = User::FromJson(jsonUser);
if (networkUser != nullptr) if (networkUser != nullptr)
{ {
_usersByHash[networkUser->Hash] = std::move(networkUser); _usersByHash[networkUser->Hash] = std::move(networkUser);
@@ -95,7 +95,7 @@ namespace OpenRCT2::Network
} }
} }
void NetworkUserManager::Save() void UserManager::Save()
{ {
const auto path = GetStorePath(); const auto path = GetStorePath();
@@ -153,7 +153,7 @@ namespace OpenRCT2::Network
Json::WriteToFile(path, jsonUsers); Json::WriteToFile(path, jsonUsers);
} }
void NetworkUserManager::UnsetUsersOfGroup(uint8_t groupId) void UserManager::UnsetUsersOfGroup(uint8_t groupId)
{ {
for (const auto& kvp : _usersByHash) for (const auto& kvp : _usersByHash)
{ {
@@ -165,16 +165,16 @@ namespace OpenRCT2::Network
} }
} }
void NetworkUserManager::RemoveUser(const std::string& hash) void UserManager::RemoveUser(const std::string& hash)
{ {
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash)); User* networkUser = const_cast<User*>(GetUserByHash(hash));
if (networkUser != nullptr) if (networkUser != nullptr)
{ {
networkUser->Remove = true; networkUser->Remove = true;
} }
} }
const NetworkUser* NetworkUserManager::GetUserByHash(const std::string& hash) const const User* UserManager::GetUserByHash(const std::string& hash) const
{ {
auto it = _usersByHash.find(hash); auto it = _usersByHash.find(hash);
if (it != _usersByHash.end()) if (it != _usersByHash.end())
@@ -184,7 +184,7 @@ namespace OpenRCT2::Network
return nullptr; return nullptr;
} }
const NetworkUser* NetworkUserManager::GetUserByName(const std::string& name) const const User* UserManager::GetUserByName(const std::string& name) const
{ {
for (const auto& kvp : _usersByHash) for (const auto& kvp : _usersByHash)
{ {
@@ -197,20 +197,20 @@ namespace OpenRCT2::Network
return nullptr; return nullptr;
} }
NetworkUser* NetworkUserManager::GetOrAddUser(const std::string& hash) User* UserManager::GetOrAddUser(const std::string& hash)
{ {
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash)); User* networkUser = const_cast<User*>(GetUserByHash(hash));
if (networkUser == nullptr) if (networkUser == nullptr)
{ {
auto newNetworkUser = std::make_unique<NetworkUser>(); auto newUser = std::make_unique<User>();
newNetworkUser->Hash = hash; newUser->Hash = hash;
networkUser = newNetworkUser.get(); networkUser = newUser.get();
_usersByHash[hash] = std::move(newNetworkUser); _usersByHash[hash] = std::move(newUser);
} }
return networkUser; return networkUser;
} }
u8string NetworkUserManager::GetStorePath() u8string UserManager::GetStorePath()
{ {
auto& env = GetContext()->GetPlatformEnvironment(); auto& env = GetContext()->GetPlatformEnvironment();
return Path::Combine(env.GetDirectoryPath(DirBase::user), kUserStoreFilename); return Path::Combine(env.GetDirectoryPath(DirBase::user), kUserStoreFilename);

24
src/openrct2/network/NetworkUser.h
View File

@@ -18,7 +18,7 @@
namespace OpenRCT2::Network namespace OpenRCT2::Network
{ {
class NetworkUser final class User final
{ {
public: public:
std::string Hash; std::string Hash;
@@ -27,28 +27,28 @@ namespace OpenRCT2::Network
bool Remove; bool Remove;
/** /**
* Creates a NetworkUser object from a JSON object * Creates a User object from a JSON object
* @param jsonData Must be a JSON node of type object * @param jsonData Must be a JSON node of type object
* @return Pointer to a new NetworkUser object * @return Pointer to a new User object
* @note jsonData is deliberately left non-const: json_t behaviour changes when const * @note jsonData is deliberately left non-const: json_t behaviour changes when const
*/ */
static std::unique_ptr<NetworkUser> FromJson(const json_t& jsonData); static std::unique_ptr<User> FromJson(const json_t& jsonData);
/** /**
* Serialise a NetworkUser object into a JSON object * Serialise a User object into a JSON object
* *
* @return JSON representation of the NetworkUser object * @return JSON representation of the User object
*/ */
json_t ToJson() const; json_t ToJson() const;
}; };
class NetworkUserManager final class UserManager final
{ {
public: public:
void Load(); void Load();
/** /**
* @brief NetworkUserManager::Save * @brief UserManager::Save
* Reads mappings from JSON, updates them in-place and saves JSON. * Reads mappings from JSON, updates them in-place and saves JSON.
* *
* Useful for retaining custom entries in JSON file. * Useful for retaining custom entries in JSON file.
@@ -58,12 +58,12 @@ namespace OpenRCT2::Network
void UnsetUsersOfGroup(uint8_t groupId); void UnsetUsersOfGroup(uint8_t groupId);
void RemoveUser(const std::string& hash); void RemoveUser(const std::string& hash);
const NetworkUser* GetUserByHash(const std::string& hash) const; const User* GetUserByHash(const std::string& hash) const;
const NetworkUser* GetUserByName(const std::string& name) const; const User* GetUserByName(const std::string& name) const;
NetworkUser* GetOrAddUser(const std::string& hash); User* GetOrAddUser(const std::string& hash);
private: private:
std::unordered_map<std::string, std::unique_ptr<NetworkUser>> _usersByHash; std::unordered_map<std::string, std::unique_ptr<User>> _usersByHash;
static u8string GetStorePath(); static u8string GetStorePath();
}; };

2
src/openrct2/network/ServerList.cpp
View File

@@ -293,7 +293,7 @@ namespace OpenRCT2::Network
size_t recievedLen{}; size_t recievedLen{};
std::unique_ptr<INetworkEndpoint> endpoint; std::unique_ptr<INetworkEndpoint> endpoint;
auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint); auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint);
if (p == NetworkReadPacket::success) if (p == ReadPacket::success)
{ {
auto sender = endpoint->GetHostname(); auto sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes back from %s", recievedLen, sender.c_str()); LOG_VERBOSE("Received %zu bytes back from %s", recievedLen, sender.c_str());

16
src/openrct2/network/Socket.cpp
View File

@@ -574,7 +574,7 @@ namespace OpenRCT2::Network
return totalSent; return totalSent;
} }
NetworkReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) override ReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) override
{ {
if (_status != SocketStatus::connected) if (_status != SocketStatus::connected)
{ {
@@ -585,7 +585,7 @@ namespace OpenRCT2::Network
if (readBytes == 0) if (readBytes == 0)
{ {
*sizeReceived = 0; *sizeReceived = 0;
return NetworkReadPacket::disconnected; return ReadPacket::disconnected;
} }
if (readBytes == SOCKET_ERROR) if (readBytes == SOCKET_ERROR)
@@ -605,14 +605,14 @@ namespace OpenRCT2::Network
#endif // _WIN32 #endif // _WIN32
if (LAST_SOCKET_ERROR() != EWOULDBLOCK) if (LAST_SOCKET_ERROR() != EWOULDBLOCK)
{ {
return NetworkReadPacket::disconnected; return ReadPacket::disconnected;
} }
return NetworkReadPacket::noData; return ReadPacket::noData;
} }
*sizeReceived = readBytes; *sizeReceived = readBytes;
return NetworkReadPacket::success; return ReadPacket::success;
} }
void Close() override void Close() override
@@ -782,7 +782,7 @@ namespace OpenRCT2::Network
return totalSent; return totalSent;
} }
NetworkReadPacket ReceiveData( ReadPacket ReceiveData(
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender) override void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender) override
{ {
sockaddr_in senderAddr{}; sockaddr_in senderAddr{};
@@ -798,7 +798,7 @@ namespace OpenRCT2::Network
if (readBytes <= 0) if (readBytes <= 0)
{ {
*sizeReceived = 0; *sizeReceived = 0;
return NetworkReadPacket::noData; return ReadPacket::noData;
} }
*sizeReceived = readBytes; *sizeReceived = readBytes;
@@ -806,7 +806,7 @@ namespace OpenRCT2::Network
{ {
*sender = std::make_unique<NetworkEndpoint>(reinterpret_cast<sockaddr*>(&senderAddr), senderAddrLen); *sender = std::make_unique<NetworkEndpoint>(reinterpret_cast<sockaddr*>(&senderAddr), senderAddrLen);
} }
return NetworkReadPacket::success; return ReadPacket::success;
} }
void Close() override void Close() override

6
src/openrct2/network/Socket.h
View File

@@ -25,7 +25,7 @@ namespace OpenRCT2::Network
listening, listening,
}; };
enum class NetworkReadPacket : int32_t enum class ReadPacket : int32_t
{ {
success, success,
noData, noData,
@@ -66,7 +66,7 @@ namespace OpenRCT2::Network
virtual void ConnectAsync(const std::string& address, uint16_t port) = 0; virtual void ConnectAsync(const std::string& address, uint16_t port) = 0;
virtual size_t SendData(const void* buffer, size_t size) = 0; virtual size_t SendData(const void* buffer, size_t size) = 0;
virtual NetworkReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) = 0; virtual ReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) = 0;
virtual void SetNoDelay(bool noDelay) = 0; virtual void SetNoDelay(bool noDelay) = 0;
@@ -92,7 +92,7 @@ namespace OpenRCT2::Network
virtual size_t SendData(const std::string& address, uint16_t port, const void* buffer, size_t size) = 0; virtual size_t SendData(const std::string& address, uint16_t port, const void* buffer, size_t size) = 0;
virtual size_t SendData(const INetworkEndpoint& destination, const void* buffer, size_t size) = 0; virtual size_t SendData(const INetworkEndpoint& destination, const void* buffer, size_t size) = 0;
virtual NetworkReadPacket ReceiveData( virtual ReadPacket ReceiveData(
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender) void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender)
= 0; = 0;

8
src/openrct2/scripting/bindings/network/ScSocket.hpp
View File

@@ -349,14 +349,14 @@ namespace OpenRCT2::Scripting
auto result = _socket->ReceiveData(buffer, sizeof(buffer), &bytesRead); auto result = _socket->ReceiveData(buffer, sizeof(buffer), &bytesRead);
switch (result) switch (result)
{ {
case Network::NetworkReadPacket::success: case Network::ReadPacket::success:
RaiseOnData(std::string(buffer, bytesRead)); RaiseOnData(std::string(buffer, bytesRead));
break; break;
case Network::NetworkReadPacket::noData: case Network::ReadPacket::noData:
break; break;
case Network::NetworkReadPacket::moreData: case Network::ReadPacket::moreData:
break; break;
case Network::NetworkReadPacket::disconnected: case Network::ReadPacket::disconnected:
CloseSocket(); CloseSocket();
break; break;
} }