mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-10 09:32:29 +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;
_port = port;
_serverConnection = std::make_unique<NetworkConnection>();
_serverConnection = std::make_unique<Connection>();
_serverConnection->Socket = CreateTcpSocket();
_serverConnection->Socket->ConnectAsync(host, port);
_serverState.gamestateSnapshotsEnabled = false;
@@ -394,7 +394,7 @@ namespace OpenRCT2::Network
if (GetMode() == Mode::server)
{
// Add SERVER to users.json and save.
NetworkUser* networkUser = _userManager.GetOrAddUser(player->KeyHash);
User* networkUser = _userManager.GetOrAddUser(player->KeyHash);
networkUser->GroupId = player->Group;
networkUser->Name = player->Name;
_userManager.Save();
@@ -449,7 +449,7 @@ namespace OpenRCT2::Network
return player_id;
}
NetworkConnection* NetworkBase::GetPlayerConnection(uint8_t id) const
Connection* NetworkBase::GetPlayerConnection(uint8_t id) const
{
auto player = GetPlayerByID(id);
if (player != nullptr)
@@ -787,7 +787,7 @@ namespace OpenRCT2::Network
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)
{
@@ -987,7 +987,7 @@ namespace OpenRCT2::Network
uint8_t NetworkBase::GetGroupIDByHash(const std::string& keyhash)
{
const NetworkUser* networkUser = _userManager.GetUserByHash(keyhash);
const User* networkUser = _userManager.GetUserByHash(keyhash);
uint8_t groupId = GetDefaultGroup();
if (networkUser != nullptr && networkUser->GroupId.has_value())
@@ -1255,7 +1255,7 @@ namespace OpenRCT2::Network
LOG_VERBOSE("Requesting gamestate from server for tick %u", tick);
NetworkPacket packet(Command::requestGameState);
Packet packet(Command::requestGameState);
packet << tick;
_serverConnection->QueuePacket(std::move(packet));
}
@@ -1263,7 +1263,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_TOKEN()
{
LOG_VERBOSE("requesting token");
NetworkPacket packet(Command::token);
Packet packet(Command::token);
_serverConnection->AuthStatus = Auth::requested;
_serverConnection->QueuePacket(std::move(packet));
}
@@ -1271,7 +1271,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_AUTH(
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(name);
packet.WriteString(password);
@@ -1286,7 +1286,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects)
{
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());
for (const auto& object : objects)
{
@@ -1306,22 +1306,22 @@ namespace OpenRCT2::Network
_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.Write(connection.Challenge.data(), connection.Challenge.size());
connection.QueuePacket(std::move(packet));
}
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());
if (objects.empty())
{
NetworkPacket packet(Command::objectsList);
Packet packet(Command::objectsList);
packet << static_cast<uint32_t>(0) << static_cast<uint32_t>(objects.size());
connection.QueuePacket(std::move(packet));
@@ -1332,7 +1332,7 @@ namespace OpenRCT2::Network
{
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());
if (object->Identifier.empty())
@@ -1355,7 +1355,7 @@ namespace OpenRCT2::Network
}
}
void NetworkBase::ServerSendScripts(NetworkConnection& connection)
void NetworkBase::ServerSendScripts(Connection& connection)
{
#ifdef ENABLE_SCRIPTING
using namespace OpenRCT2::Scripting;
@@ -1378,7 +1378,7 @@ namespace OpenRCT2::Network
}
// Send the header packet.
NetworkPacket packetScriptHeader(Command::scriptsHeader);
Packet packetScriptHeader(Command::scriptsHeader);
packetScriptHeader << static_cast<uint32_t>(remotePlugins.size());
packetScriptHeader << static_cast<uint32_t>(pluginData.GetLength());
connection.QueuePacket(std::move(packetScriptHeader));
@@ -1390,7 +1390,7 @@ namespace OpenRCT2::Network
{
const uint32_t chunkSize = std::min<uint32_t>(pluginData.GetLength() - dataOffset, kChunkSize);
NetworkPacket packet(Command::scriptsData);
Packet packet(Command::scriptsData);
packet << chunkSize;
packet.Write(pluginDataBuffer + dataOffset, chunkSize);
@@ -1401,17 +1401,17 @@ namespace OpenRCT2::Network
Guard::Assert(dataOffset == pluginData.GetLength());
#else
NetworkPacket packetScriptHeader(Command::scriptsHeader);
Packet packetScriptHeader(Command::scriptsHeader);
packetScriptHeader << static_cast<uint32_t>(0u);
packetScriptHeader << static_cast<uint32_t>(0u);
#endif
}
void NetworkBase::Client_Send_HEARTBEAT(NetworkConnection& connection) const
void NetworkBase::Client_Send_HEARTBEAT(Connection& connection) const
{
LOG_VERBOSE("Sending heartbeat");
NetworkPacket packet(Command::heartbeat);
Packet packet(Command::heartbeat);
connection.QueuePacket(std::move(packet));
}
@@ -1436,14 +1436,14 @@ namespace OpenRCT2::Network
return stats;
}
void NetworkBase::ServerSendAuth(NetworkConnection& connection)
void NetworkBase::ServerSendAuth(Connection& connection)
{
uint8_t new_playerid = 0;
if (connection.player != nullptr)
{
new_playerid = connection.player->Id;
}
NetworkPacket packet(Command::auth);
Packet packet(Command::auth);
packet << static_cast<uint32_t>(connection.AuthStatus) << new_playerid;
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;
if (connection != nullptr)
@@ -1486,7 +1486,7 @@ namespace OpenRCT2::Network
for (size_t i = 0; i < header.size(); i += chunksize)
{
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.Write(&header[i], datasize);
if (connection != nullptr)
@@ -1518,14 +1518,14 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_CHAT(const char* text)
{
NetworkPacket packet(Command::chat);
Packet packet(Command::chat);
packet.WriteString(text);
_serverConnection->QueuePacket(std::move(packet));
}
void NetworkBase::ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds)
{
NetworkPacket packet(Command::chat);
Packet packet(Command::chat);
packet.WriteString(text);
if (playerIds.empty())
@@ -1548,7 +1548,7 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_GAME_ACTION(const GameActions::GameAction* action)
{
NetworkPacket packet(Command::gameAction);
Packet packet(Command::gameAction);
uint32_t networkId = 0;
networkId = ++_actionId;
@@ -1569,7 +1569,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendGameAction(const GameActions::GameAction* action)
{
NetworkPacket packet(Command::gameAction);
Packet packet(Command::gameAction);
DataSerialiser stream(true);
action->Serialise(stream);
@@ -1581,7 +1581,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendTick()
{
NetworkPacket packet(Command::tick);
Packet packet(Command::tick);
packet << getGameState().currentTicks << ScenarioRandState().s0;
uint32_t flags = 0;
// Simple counter which limits how often a sprite checksum gets sent.
@@ -1608,7 +1608,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPlayerInfo(int32_t playerId)
{
NetworkPacket packet(Command::playerInfo);
Packet packet(Command::playerInfo);
packet << getGameState().currentTicks;
auto* player = GetPlayerByID(playerId);
@@ -1621,7 +1621,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPlayerList()
{
NetworkPacket packet(Command::playerList);
Packet packet(Command::playerList);
packet << getGameState().currentTicks << static_cast<uint8_t>(player_list.size());
for (auto& player : player_list)
{
@@ -1632,14 +1632,14 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_PING()
{
NetworkPacket packet(Command::ping);
Packet packet(Command::ping);
_serverConnection->QueuePacket(std::move(packet));
}
void NetworkBase::ServerSendPing()
{
last_ping_sent_time = Platform::GetTicks();
NetworkPacket packet(Command::ping);
Packet packet(Command::ping);
for (auto& client_connection : client_connection_list)
{
client_connection->PingTime = Platform::GetTicks();
@@ -1649,7 +1649,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendPingList()
{
NetworkPacket packet(Command::pingList);
Packet packet(Command::pingList);
packet << static_cast<uint8_t>(player_list.size());
for (auto& player : player_list)
{
@@ -1658,9 +1658,9 @@ namespace OpenRCT2::Network
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);
connection.QueuePacket(std::move(packet));
}
@@ -1680,9 +1680,9 @@ namespace OpenRCT2::Network
return jsonObj;
}
void NetworkBase::ServerSendGameInfo(NetworkConnection& connection)
void NetworkBase::ServerSendGameInfo(Connection& connection)
{
NetworkPacket packet(Command::gameInfo);
Packet packet(Command::gameInfo);
#ifndef DISABLE_HTTP
json_t jsonObj = GetServerInfoAsJson();
@@ -1703,16 +1703,16 @@ namespace OpenRCT2::Network
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;
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;
for (auto& group : group_list)
{
@@ -1723,7 +1723,7 @@ namespace OpenRCT2::Network
void NetworkBase::ServerSendEventPlayerJoined(const char* playerName)
{
NetworkPacket packet(Command::event);
Packet packet(Command::event);
packet << static_cast<uint16_t>(SERVER_EVENT_PLAYER_JOINED);
packet.WriteString(playerName);
SendPacketToClients(packet);
@@ -1731,32 +1731,32 @@ namespace OpenRCT2::Network
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.WriteString(playerName);
packet.WriteString(reason);
SendPacketToClients(packet);
}
bool NetworkBase::ProcessConnection(NetworkConnection& connection)
bool NetworkBase::ProcessConnection(Connection& connection)
{
NetworkReadPacket packetStatus;
ReadPacket packetStatus;
uint32_t countProcessed = 0;
do
{
countProcessed++;
packetStatus = connection.ReadPacket();
packetStatus = connection.readPacket();
switch (packetStatus)
{
case NetworkReadPacket::disconnected:
case ReadPacket::disconnected:
// closed connection or network error
if (!connection.GetLastDisconnectReason())
{
connection.SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
}
return false;
case NetworkReadPacket::success:
case ReadPacket::success:
// done reading in packet
ProcessPacket(connection, connection.InboundPacket);
if (!connection.IsValid())
@@ -1764,14 +1764,14 @@ namespace OpenRCT2::Network
return false;
}
break;
case NetworkReadPacket::moreData:
case ReadPacket::moreData:
// more data required to be read
break;
case NetworkReadPacket::noData:
case ReadPacket::noData:
// could not read anything from socket
break;
}
} while (packetStatus == NetworkReadPacket::success && countProcessed < kMaxPacketsPerUpdate);
} while (packetStatus == ReadPacket::success && countProcessed < kMaxPacketsPerUpdate);
if (!connection.ReceivedPacketRecently())
{
@@ -1785,7 +1785,7 @@ namespace OpenRCT2::Network
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;
@@ -1824,7 +1824,7 @@ namespace OpenRCT2::Network
}
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
using namespace OpenRCT2::Scripting;
@@ -2039,13 +2039,13 @@ namespace OpenRCT2::Network
AppendServerLog(addr);
// Store connection
auto connection = std::make_unique<NetworkConnection>();
auto connection = std::make_unique<Connection>();
connection->Socket = std::move(socket);
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;
if (connection_player == nullptr)
@@ -2084,7 +2084,7 @@ namespace OpenRCT2::Network
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;
if (connection_player == nullptr)
@@ -2132,7 +2132,7 @@ namespace OpenRCT2::Network
_userManager.Load();
// Check if the key is registered
const NetworkUser* networkUser = _userManager.GetUserByHash(keyhash);
const User* networkUser = _userManager.GetUserByHash(keyhash);
player = std::make_unique<Player>();
player->Id = newid;
@@ -2208,7 +2208,7 @@ namespace OpenRCT2::Network
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);
if (!File::Exists(keyPath))
@@ -2256,7 +2256,7 @@ namespace OpenRCT2::Network
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;
packet >> tick;
@@ -2287,7 +2287,7 @@ namespace OpenRCT2::Network
dataSize = snapshotMemory.GetLength() - bytesSent;
}
NetworkPacket packetGameStateChunk(Command::gameState);
Packet packetGameStateChunk(Command::gameState);
packetGameStateChunk << tick << length << 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());
connection.ResetLastPacketTime();
}
void NetworkBase::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::Client_Handle_AUTH(Connection& connection, Packet& packet)
{
uint32_t auth_status;
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);
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);
connection.Challenge.resize(token_size);
@@ -2399,7 +2399,7 @@ namespace OpenRCT2::Network
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();
@@ -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 dataSize{};
@@ -2487,7 +2487,7 @@ namespace OpenRCT2::Network
#endif
}
void NetworkBase::Client_Handle_SCRIPTS_DATA(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::Client_Handle_SCRIPTS_DATA(Connection& connection, Packet& packet)
{
#ifdef ENABLE_SCRIPTING
uint32_t dataSize{};
@@ -2524,7 +2524,7 @@ namespace OpenRCT2::Network
#endif
}
void NetworkBase::Client_Handle_GAMESTATE(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::Client_Handle_GAMESTATE(Connection& connection, Packet& packet)
{
uint32_t tick;
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;
packet >> size;
@@ -2636,7 +2636,7 @@ namespace OpenRCT2::Network
ServerSendGroupList(connection);
}
void NetworkBase::ServerHandleAuth(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::ServerHandleAuth(Connection& connection, Packet& packet)
{
if (connection.AuthStatus != Auth::ok)
{
@@ -2676,13 +2676,13 @@ namespace OpenRCT2::Network
std::memcpy(signature.data(), signatureData, sigsize);
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.");
}
bool verified = connection.Key.Verify(connection.Challenge.data(), connection.Challenge.size(), signature);
const std::string hash = connection.Key.PublicKeyHash();
bool verified = connection.key.Verify(connection.Challenge.data(), connection.Challenge.size(), signature);
const std::string hash = connection.key.PublicKeyHash();
if (verified)
{
LOG_VERBOSE("Connection %s: Signature verification ok. Hash %s", hostName, hash.c_str());
@@ -2712,7 +2712,7 @@ namespace OpenRCT2::Network
bool passwordless = false;
if (connection.AuthStatus == Auth::verified)
{
const NetworkGroup* group = GetGroupByID(GetGroupIDByHash(connection.Key.PublicKeyHash()));
const NetworkGroup* group = GetGroupByID(GetGroupIDByHash(connection.key.PublicKeyHash()));
if (group != nullptr)
{
passwordless = group->CanPerformAction(Permission::PasswordlessLogin);
@@ -2749,7 +2749,7 @@ namespace OpenRCT2::Network
}
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))
{
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;
packet >> size >> offset;
@@ -2896,7 +2896,7 @@ namespace OpenRCT2::Network
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();
if (!text.empty())
@@ -2941,7 +2941,7 @@ namespace OpenRCT2::Network
return true;
}
void NetworkBase::ServerHandleChat(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::ServerHandleChat(Connection& connection, Packet& packet)
{
auto szText = packet.ReadString();
if (szText.empty())
@@ -2971,7 +2971,7 @@ namespace OpenRCT2::Network
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;
GameCommand actionType;
@@ -3007,7 +3007,7 @@ namespace OpenRCT2::Network
GameActions::Enqueue(std::move(action), tick);
}
void NetworkBase::ServerHandleGameAction(NetworkConnection& connection, NetworkPacket& packet)
void NetworkBase::ServerHandleGameAction(Connection& connection, Packet& packet)
{
uint32_t tick;
GameCommand actionType;
@@ -3079,7 +3079,7 @@ namespace OpenRCT2::Network
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 flags;
@@ -3110,7 +3110,7 @@ namespace OpenRCT2::Network
_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;
packet >> tick;
@@ -3121,7 +3121,7 @@ namespace OpenRCT2::Network
_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;
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();
}
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;
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;
packet >> size;
@@ -3179,7 +3179,7 @@ namespace OpenRCT2::Network
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();
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);
}
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;
packet >> 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();
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;
packet >> eventType;
@@ -3249,11 +3249,11 @@ namespace OpenRCT2::Network
void NetworkBase::Client_Send_GAMEINFO()
{
LOG_VERBOSE("requesting gameinfo");
NetworkPacket packet(Command::gameInfo);
Packet packet(Command::gameInfo);
_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();
packet >> _serverState.gamestateSnapshotsEnabled;
@@ -3616,8 +3616,8 @@ namespace OpenRCT2::Network
if (GetMode() == Mode::server)
{
// Add or update saved user
NetworkUserManager& userManager = network._userManager;
NetworkUser* networkUser = userManager.GetOrAddUser(player->KeyHash);
UserManager& userManager = network._userManager;
User* networkUser = userManager.GetOrAddUser(player->KeyHash);
networkUser->GroupId = groupId;
networkUser->Name = player->Name;
userManager.Save();
@@ -3804,7 +3804,7 @@ namespace OpenRCT2::Network
{
network.KickPlayer(playerId);
NetworkUserManager& networkUserManager = network._userManager;
UserManager& networkUserManager = network._userManager;
networkUserManager.Load();
networkUserManager.RemoveUser(player->KeyHash);
networkUserManager.Save();

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

@@ -57,13 +57,13 @@ namespace OpenRCT2::Network
void CloseChatLog();
Stats GetStats() const;
json_t GetServerInfoAsJson() const;
bool ProcessConnection(NetworkConnection& connection);
bool ProcessConnection(Connection& connection);
void CloseConnection();
Player* AddPlayer(const std::string& name, const std::string& keyhash);
void ProcessPacket(NetworkConnection& connection, NetworkPacket& packet);
void ProcessPacket(Connection& connection, Packet& packet);
public: // Server
NetworkConnection* GetPlayerConnection(uint8_t id) const;
Connection* GetPlayerConnection(uint8_t id) const;
void KickPlayer(int32_t playerId);
NetworkGroup* AddGroup();
void LoadGroups();
@@ -79,17 +79,17 @@ namespace OpenRCT2::Network
std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey();
void SetupDefaultGroups();
void RemovePlayer(std::unique_ptr<NetworkConnection>& connection);
void RemovePlayer(std::unique_ptr<Connection>& connection);
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;
std::vector<uint8_t> SaveForNetwork(const std::vector<const ObjectRepositoryItem*>& objects) const;
std::string MakePlayerNameUnique(const std::string& name);
// Packet dispatchers.
void ServerSendAuth(NetworkConnection& connection);
void ServerSendToken(NetworkConnection& connection);
void ServerSendMap(NetworkConnection* connection = nullptr);
void ServerSendAuth(Connection& connection);
void ServerSendToken(Connection& connection);
void ServerSendMap(Connection* connection = nullptr);
void ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void ServerSendGameAction(const GameActions::GameAction* action);
void ServerSendTick();
@@ -97,27 +97,26 @@ namespace OpenRCT2::Network
void ServerSendPlayerList();
void ServerSendPing();
void ServerSendPingList();
void ServerSendSetDisconnectMsg(NetworkConnection& connection, const char* msg);
void ServerSendGameInfo(NetworkConnection& connection);
void ServerSendShowError(NetworkConnection& connection, StringId title, StringId message);
void ServerSendGroupList(NetworkConnection& connection);
void ServerSendSetDisconnectMsg(Connection& connection, const char* msg);
void ServerSendGameInfo(Connection& connection);
void ServerSendShowError(Connection& connection, StringId title, StringId message);
void ServerSendGroupList(Connection& connection);
void ServerSendEventPlayerJoined(const char* playerName);
void ServerSendEventPlayerDisconnected(const char* playerName, const char* reason);
void ServerSendObjectsList(
NetworkConnection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const;
void ServerSendScripts(NetworkConnection& connection);
void ServerSendObjectsList(Connection& connection, const std::vector<const ObjectRepositoryItem*>& objects) const;
void ServerSendScripts(Connection& connection);
// Handlers
void ServerHandleRequestGamestate(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleHeartbeat(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleAuth(NetworkConnection& connection, NetworkPacket& packet);
void ServerClientJoined(std::string_view name, const std::string& keyhash, NetworkConnection& connection);
void ServerHandleChat(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleGameAction(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandlePing(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleGameInfo(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleToken(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleMapRequest(NetworkConnection& connection, NetworkPacket& packet);
void ServerHandleRequestGamestate(Connection& connection, Packet& packet);
void ServerHandleHeartbeat(Connection& connection, Packet& packet);
void ServerHandleAuth(Connection& connection, Packet& packet);
void ServerClientJoined(std::string_view name, const std::string& keyhash, Connection& connection);
void ServerHandleChat(Connection& connection, Packet& packet);
void ServerHandleGameAction(Connection& connection, Packet& packet);
void ServerHandlePing(Connection& connection, Packet& packet);
void ServerHandleGameInfo(Connection& connection, Packet& packet);
void ServerHandleToken(Connection& connection, Packet& packet);
void ServerHandleMapRequest(Connection& connection, Packet& packet);
public: // Client
void Reconnect();
@@ -128,7 +127,7 @@ namespace OpenRCT2::Network
void ProcessPlayerInfo();
void ProcessDisconnectedClients();
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 CheckDesynchronizaton();
void RequestStateSnapshot();
@@ -149,33 +148,33 @@ namespace OpenRCT2::Network
void Client_Send_PING();
void Client_Send_GAMEINFO();
void Client_Send_MAPREQUEST(const std::vector<ObjectEntryDescriptor>& objects);
void Client_Send_HEARTBEAT(NetworkConnection& connection) const;
void Client_Send_HEARTBEAT(Connection& connection) const;
// Handlers.
void Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_MAP(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_CHAT(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_GAME_ACTION(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_TICK(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_PLAYERINFO(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_PLAYERLIST(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_PING(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_PINGLIST(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_GAMEINFO(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_SHOWERROR(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_GROUPLIST(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_EVENT(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_OBJECTS_LIST(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_SCRIPTS_HEADER(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_SCRIPTS_DATA(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_GAMESTATE(NetworkConnection& connection, NetworkPacket& packet);
void Client_Handle_AUTH(Connection& connection, Packet& packet);
void Client_Handle_MAP(Connection& connection, Packet& packet);
void Client_Handle_CHAT(Connection& connection, Packet& packet);
void Client_Handle_GAME_ACTION(Connection& connection, Packet& packet);
void Client_Handle_TICK(Connection& connection, Packet& packet);
void Client_Handle_PLAYERINFO(Connection& connection, Packet& packet);
void Client_Handle_PLAYERLIST(Connection& connection, Packet& packet);
void Client_Handle_PING(Connection& connection, Packet& packet);
void Client_Handle_PINGLIST(Connection& connection, Packet& packet);
void Client_Handle_SETDISCONNECTMSG(Connection& connection, Packet& packet);
void Client_Handle_GAMEINFO(Connection& connection, Packet& packet);
void Client_Handle_SHOWERROR(Connection& connection, Packet& packet);
void Client_Handle_GROUPLIST(Connection& connection, Packet& packet);
void Client_Handle_EVENT(Connection& connection, Packet& packet);
void Client_Handle_TOKEN(Connection& connection, Packet& packet);
void Client_Handle_OBJECTS_LIST(Connection& connection, Packet& packet);
void Client_Handle_SCRIPTS_HEADER(Connection& connection, Packet& packet);
void Client_Handle_SCRIPTS_DATA(Connection& connection, Packet& packet);
void Client_Handle_GAMESTATE(Connection& connection, Packet& packet);
std::vector<uint8_t> _challenge;
std::map<uint32_t, GameActions::GameAction::Callback_t> _gameActionCallbacks;
NetworkKey _key;
NetworkUserManager _userManager;
Key _key;
UserManager _userManager;
public: // Public common
std::string ServerName;
@@ -189,7 +188,7 @@ namespace OpenRCT2::Network
bool IsServerPlayerInvisible = false;
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::ofstream _chat_log_fs;
@@ -204,7 +203,7 @@ namespace OpenRCT2::Network
std::unordered_map<Command, CommandHandler> server_command_handlers;
std::unique_ptr<ITcpSocket> _listenSocket;
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 _serverLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::ofstream _server_log_fs;
@@ -232,7 +231,7 @@ namespace OpenRCT2::Network
};
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::multimap<uint32_t, Player> _pendingPlayerInfo;
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.");
NetworkConnection::NetworkConnection() noexcept
Connection::Connection() noexcept
{
ResetLastPacketTime();
}
NetworkReadPacket NetworkConnection::ReadPacket()
ReadPacket Connection::readPacket()
{
size_t bytesRead = 0;
@@ -46,8 +46,8 @@ namespace OpenRCT2::Network
uint8_t* buffer = reinterpret_cast<uint8_t*>(&InboundPacket.Header);
NetworkReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead);
if (status != NetworkReadPacket::success)
ReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead);
if (status != ReadPacket::success)
{
return status;
}
@@ -56,7 +56,7 @@ namespace OpenRCT2::Network
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
{
// If still not enough data for header, keep waiting.
return NetworkReadPacket::moreData;
return ReadPacket::moreData;
}
// Normalise values.
@@ -79,8 +79,8 @@ namespace OpenRCT2::Network
if (missingLength > 0)
{
NetworkReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kBufferSize), &bytesRead);
if (status != NetworkReadPacket::success)
ReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kBufferSize), &bytesRead);
if (status != ReadPacket::success)
{
return status;
}
@@ -96,14 +96,14 @@ namespace OpenRCT2::Network
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.
// Previously the Id field was not part of the header rather part of the body.
@@ -125,7 +125,7 @@ namespace OpenRCT2::Network
return buffer;
}
void NetworkConnection::QueuePacket(const NetworkPacket& packet, bool front)
void Connection::QueuePacket(const Packet& packet, bool front)
{
if (AuthStatus == Auth::ok || !packet.CommandRequiresAuth())
{
@@ -143,17 +143,17 @@ namespace OpenRCT2::Network
}
}
void NetworkConnection::Disconnect() noexcept
void Connection::Disconnect() noexcept
{
ShouldDisconnect = true;
}
bool NetworkConnection::IsValid() const
bool Connection::IsValid() const
{
return !ShouldDisconnect && Socket->GetStatus() == SocketStatus::connected;
}
void NetworkConnection::SendQueuedData()
void Connection::SendQueuedData()
{
if (_outboundBuffer.empty())
{
@@ -168,12 +168,12 @@ namespace OpenRCT2::Network
}
}
void NetworkConnection::ResetLastPacketTime() noexcept
void Connection::ResetLastPacketTime() noexcept
{
_lastPacketTime = Platform::GetTicks();
}
bool NetworkConnection::ReceivedPacketRecently() const noexcept
bool Connection::ReceivedPacketRecently() const noexcept
{
#ifndef DEBUG
constexpr auto kTimeoutMs = kNoDataTimeout * 1000;
@@ -185,24 +185,24 @@ namespace OpenRCT2::Network
return true;
}
const utf8* NetworkConnection::GetLastDisconnectReason() const noexcept
const utf8* Connection::GetLastDisconnectReason() const noexcept
{
return this->_lastDisconnectReason.c_str();
}
void NetworkConnection::SetLastDisconnectReason(std::string_view src)
void Connection::SetLastDisconnectReason(std::string_view src)
{
_lastDisconnectReason = src;
}
void NetworkConnection::SetLastDisconnectReason(const StringId string_id, void* args)
void Connection::SetLastDisconnectReason(const StringId string_id, void* args)
{
char buffer[kDisconnectReasonBufSize];
FormatStringLegacy(buffer, kDisconnectReasonBufSize, string_id, args);
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);
StatisticsGroup trafficGroup;

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

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

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

@@ -76,7 +76,7 @@ namespace OpenRCT2::Network
_name = name;
}
void NetworkGroup::Read(NetworkPacket& packet)
void NetworkGroup::Read(Packet& packet)
{
packet >> Id;
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.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;
void SetName(std::string_view name);
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet) const;
void Read(Packet& packet);
void Write(Packet& packet) const;
void ToggleActionPermission(Permission index);
bool CanPerformAction(Permission index) const noexcept;
bool CanPerformCommand(GameCommand command) const;

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

@@ -21,15 +21,15 @@
namespace OpenRCT2::Network
{
NetworkKey::NetworkKey() = default;
NetworkKey::~NetworkKey() = default;
Key::Key() = default;
Key::~Key() = default;
void NetworkKey::Unload()
void Key::Unload()
{
_key = nullptr;
}
bool NetworkKey::Generate()
bool Key::Generate()
{
try
{
@@ -39,12 +39,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Generate failed: %s", e.what());
LOG_ERROR("Network::Key::Generate failed: %s", e.what());
return false;
}
}
bool NetworkKey::LoadPrivate(IStream* stream)
bool Key::LoadPrivate(IStream* stream)
{
Guard::ArgumentNotNull(stream);
@@ -71,12 +71,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPrivate failed: %s", e.what());
LOG_ERROR("Network::Key::LoadPrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::LoadPublic(IStream* stream)
bool Key::LoadPublic(IStream* stream)
{
Guard::ArgumentNotNull(stream);
@@ -103,12 +103,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPublic failed: %s", e.what());
LOG_ERROR("Network::Key::LoadPublic failed: %s", e.what());
return false;
}
}
bool NetworkKey::SavePrivate(IStream* stream)
bool Key::SavePrivate(IStream* stream)
{
try
{
@@ -122,12 +122,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePrivate failed: %s", e.what());
LOG_ERROR("Network::Key::SavePrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::SavePublic(IStream* stream)
bool Key::SavePublic(IStream* stream)
{
try
{
@@ -141,12 +141,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePublic failed: %s", e.what());
LOG_ERROR("Network::Key::SavePublic failed: %s", e.what());
return false;
}
}
std::string NetworkKey::PublicKeyString()
std::string Key::PublicKeyString()
{
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
* public key. Serves a purpose of easy identification keys in multiplayer
* overview, multiplayer settings.
@@ -166,7 +166,7 @@ namespace OpenRCT2::Network
*
* @return returns a string containing key hash.
*/
std::string NetworkKey::PublicKeyHash()
std::string Key::PublicKeyHash()
{
try
{
@@ -185,7 +185,7 @@ namespace OpenRCT2::Network
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
{
@@ -195,12 +195,12 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Sign failed: %s", e.what());
LOG_ERROR("Network::Key::Sign failed: %s", e.what());
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
{
@@ -209,7 +209,7 @@ namespace OpenRCT2::Network
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Verify failed: %s", e.what());
LOG_ERROR("Network::Key::Verify failed: %s", e.what());
return false;
}
}

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

@@ -27,11 +27,11 @@ namespace OpenRCT2::Crypt
namespace OpenRCT2::Network
{
class NetworkKey final
class Key final
{
public:
NetworkKey();
~NetworkKey();
Key();
~Key();
bool Generate();
bool LoadPrivate(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;
private:
NetworkKey(const NetworkKey&) = delete;
Key(const Key&) = delete;
std::unique_ptr<Crypt::RsaKey> _key;
};
} // namespace OpenRCT2::Network

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

@@ -17,34 +17,34 @@
namespace OpenRCT2::Network
{
NetworkPacket::NetworkPacket(Command id) noexcept
Packet::Packet(Command id) noexcept
: Header{ 0, id }
{
}
uint8_t* NetworkPacket::GetData() noexcept
uint8_t* Packet::GetData() noexcept
{
return Data.data();
}
const uint8_t* NetworkPacket::GetData() const noexcept
const uint8_t* Packet::GetData() const noexcept
{
return Data.data();
}
Command NetworkPacket::GetCommand() const noexcept
Command Packet::GetCommand() const noexcept
{
return Header.Id;
}
void NetworkPacket::Clear() noexcept
void Packet::Clear() noexcept
{
BytesTransferred = 0;
BytesRead = 0;
Data.clear();
}
bool NetworkPacket::CommandRequiresAuth() const noexcept
bool Packet::CommandRequiresAuth() const noexcept
{
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);
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());
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())
{
@@ -87,7 +87,7 @@ namespace OpenRCT2::Network
return data;
}
std::string_view NetworkPacket::ReadString()
std::string_view Packet::ReadString()
{
if (BytesRead >= Data.size())
return {};

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

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

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

@@ -23,7 +23,7 @@ namespace OpenRCT2::Network
Name = name.substr(0, 36);
}
void Player::Read(NetworkPacket& packet)
void Player::Read(Packet& packet)
{
auto name = packet.ReadString();
SetName(name);
@@ -31,7 +31,7 @@ namespace OpenRCT2::Network
>> MoneySpent >> CommandsRan;
}
void Player::Write(NetworkPacket& packet)
void Player::Write(Packet& packet)
{
packet.WriteString(Name);
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
{
struct NetworkPacket;
struct Packet;
class Player final
{
@@ -46,8 +46,8 @@ namespace OpenRCT2::Network
void SetName(std::string_view name);
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet);
void Read(Packet& packet);
void Write(Packet& packet);
void IncrementNumCommands();
void AddMoneySpent(money64 cost);
};

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

@@ -116,7 +116,7 @@ namespace OpenRCT2::Network
size_t recievedBytes{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = _lanListener->ReceiveData(buffer, sizeof(buffer) - 1, &recievedBytes, &endpoint);
if (p == NetworkReadPacket::success)
if (p == ReadPacket::success)
{
std::string sender = endpoint->GetHostname();
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";
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 name = Json::GetString(jsonData["name"]);
json_t jsonGroupId = jsonData["groupId"];
std::unique_ptr<NetworkUser> user = nullptr;
std::unique_ptr<User> user = nullptr;
if (!hash.empty() && !name.empty())
{
user = std::make_unique<NetworkUser>();
user = std::make_unique<User>();
user->Hash = hash;
user->Name = name;
if (jsonGroupId.is_number_integer())
@@ -49,7 +49,7 @@ namespace OpenRCT2::Network
return user;
}
json_t NetworkUser::ToJson() const
json_t User::ToJson() const
{
json_t jsonData;
jsonData["hash"] = Hash;
@@ -65,7 +65,7 @@ namespace OpenRCT2::Network
return jsonData;
}
void NetworkUserManager::Load()
void UserManager::Load()
{
const auto path = GetStorePath();
@@ -80,7 +80,7 @@ namespace OpenRCT2::Network
{
if (jsonUser.is_object())
{
auto networkUser = NetworkUser::FromJson(jsonUser);
auto networkUser = User::FromJson(jsonUser);
if (networkUser != nullptr)
{
_usersByHash[networkUser->Hash] = std::move(networkUser);
@@ -95,7 +95,7 @@ namespace OpenRCT2::Network
}
}
void NetworkUserManager::Save()
void UserManager::Save()
{
const auto path = GetStorePath();
@@ -153,7 +153,7 @@ namespace OpenRCT2::Network
Json::WriteToFile(path, jsonUsers);
}
void NetworkUserManager::UnsetUsersOfGroup(uint8_t groupId)
void UserManager::UnsetUsersOfGroup(uint8_t groupId)
{
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)
{
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);
if (it != _usersByHash.end())
@@ -184,7 +184,7 @@ namespace OpenRCT2::Network
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)
{
@@ -197,20 +197,20 @@ namespace OpenRCT2::Network
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)
{
auto newNetworkUser = std::make_unique<NetworkUser>();
newNetworkUser->Hash = hash;
networkUser = newNetworkUser.get();
_usersByHash[hash] = std::move(newNetworkUser);
auto newUser = std::make_unique<User>();
newUser->Hash = hash;
networkUser = newUser.get();
_usersByHash[hash] = std::move(newUser);
}
return networkUser;
}
u8string NetworkUserManager::GetStorePath()
u8string UserManager::GetStorePath()
{
auto& env = GetContext()->GetPlatformEnvironment();
return Path::Combine(env.GetDirectoryPath(DirBase::user), kUserStoreFilename);

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

@@ -18,7 +18,7 @@
namespace OpenRCT2::Network
{
class NetworkUser final
class User final
{
public:
std::string Hash;
@@ -27,28 +27,28 @@ namespace OpenRCT2::Network
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
* @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
*/
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;
};
class NetworkUserManager final
class UserManager final
{
public:
void Load();
/**
* @brief NetworkUserManager::Save
* @brief UserManager::Save
* Reads mappings from JSON, updates them in-place and saves JSON.
*
* Useful for retaining custom entries in JSON file.
@@ -58,12 +58,12 @@ namespace OpenRCT2::Network
void UnsetUsersOfGroup(uint8_t groupId);
void RemoveUser(const std::string& hash);
const NetworkUser* GetUserByHash(const std::string& hash) const;
const NetworkUser* GetUserByName(const std::string& name) const;
NetworkUser* GetOrAddUser(const std::string& hash);
const User* GetUserByHash(const std::string& hash) const;
const User* GetUserByName(const std::string& name) const;
User* GetOrAddUser(const std::string& hash);
private:
std::unordered_map<std::string, std::unique_ptr<NetworkUser>> _usersByHash;
std::unordered_map<std::string, std::unique_ptr<User>> _usersByHash;
static u8string GetStorePath();
};

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

@@ -293,7 +293,7 @@ namespace OpenRCT2::Network
size_t recievedLen{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint);
if (p == NetworkReadPacket::success)
if (p == ReadPacket::success)
{
auto sender = endpoint->GetHostname();
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;
}
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)
{
@@ -585,7 +585,7 @@ namespace OpenRCT2::Network
if (readBytes == 0)
{
*sizeReceived = 0;
return NetworkReadPacket::disconnected;
return ReadPacket::disconnected;
}
if (readBytes == SOCKET_ERROR)
@@ -605,14 +605,14 @@ namespace OpenRCT2::Network
#endif // _WIN32
if (LAST_SOCKET_ERROR() != EWOULDBLOCK)
{
return NetworkReadPacket::disconnected;
return ReadPacket::disconnected;
}
return NetworkReadPacket::noData;
return ReadPacket::noData;
}
*sizeReceived = readBytes;
return NetworkReadPacket::success;
return ReadPacket::success;
}
void Close() override
@@ -782,7 +782,7 @@ namespace OpenRCT2::Network
return totalSent;
}
NetworkReadPacket ReceiveData(
ReadPacket ReceiveData(
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender) override
{
sockaddr_in senderAddr{};
@@ -798,7 +798,7 @@ namespace OpenRCT2::Network
if (readBytes <= 0)
{
*sizeReceived = 0;
return NetworkReadPacket::noData;
return ReadPacket::noData;
}
*sizeReceived = readBytes;
@@ -806,7 +806,7 @@ namespace OpenRCT2::Network
{
*sender = std::make_unique<NetworkEndpoint>(reinterpret_cast<sockaddr*>(&senderAddr), senderAddrLen);
}
return NetworkReadPacket::success;
return ReadPacket::success;
}
void Close() override

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

@@ -25,7 +25,7 @@ namespace OpenRCT2::Network
listening,
};
enum class NetworkReadPacket : int32_t
enum class ReadPacket : int32_t
{
success,
noData,
@@ -66,7 +66,7 @@ namespace OpenRCT2::Network
virtual void ConnectAsync(const std::string& address, uint16_t port) = 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;
@@ -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 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)
= 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);
switch (result)
{
case Network::NetworkReadPacket::success:
case Network::ReadPacket::success:
RaiseOnData(std::string(buffer, bytesRead));
break;
case Network::NetworkReadPacket::noData:
case Network::ReadPacket::noData:
break;
case Network::NetworkReadPacket::moreData:
case Network::ReadPacket::moreData:
break;
case Network::NetworkReadPacket::disconnected:
case Network::ReadPacket::disconnected:
CloseSocket();
break;
}