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

Move network units to OpenRCT2::Network namespace

Browse Source
This commit is contained in:
Aaron van Geffen
2025-08-31 15:26:10 +02:00
parent d6e9f3d205
commit 6ea5959b2b
28 changed files with 7396 additions and 7311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

226
src/openrct2/network/DiscordService.cpp
View File

@@ -24,130 +24,128 @@
#include <chrono>
#include <discord_rpc.h>
using namespace OpenRCT2;
namespace
namespace OpenRCT2::Network
{
using namespace std::chrono_literals;
constexpr const char* kApplicationID = "378612438200877056";
constexpr const char* kSteamAppID = nullptr;
constexpr auto kRefreshInterval = 5.0s;
} // namespace
static void OnReady([[maybe_unused]] const DiscordUser* request)
{
LOG_VERBOSE("DiscordService::OnReady()");
}
static void OnDisconnected(int errorCode, const char* message)
{
Console::Error::WriteLine("DiscordService::OnDisconnected(%d, %s)", errorCode, message);
}
static void OnErrored(int errorCode, const char* message)
{
Console::Error::WriteLine("DiscordService::OnErrored(%d, %s)", errorCode, message);
}
DiscordService::DiscordService()
{
DiscordEventHandlers handlers = {};
handlers.ready = OnReady;
handlers.disconnected = OnDisconnected;
handlers.errored = OnErrored;
Discord_Initialize(kApplicationID, &handlers, 1, kSteamAppID);
}
DiscordService::~DiscordService()
{
Discord_Shutdown();
}
static std::string GetParkName()
{
auto& gameState = getGameState();
return gameState.park.name;
}
void DiscordService::Tick()
{
Discord_RunCallbacks();
if (_updateTimer.GetElapsedTime() < kRefreshInterval)
return;
RefreshPresence();
_updateTimer.Restart();
}
void DiscordService::RefreshPresence() const
{
DiscordRichPresence discordPresence = {};
discordPresence.largeImageKey = "logo";
std::string state;
std::string details;
std::string partyId;
switch (gLegacyScene)
static void OnReady([[maybe_unused]] const DiscordUser* request)
{
default:
details = GetParkName();
if (NetworkGetMode() == NETWORK_MODE_NONE)
{
state = "Playing Solo";
}
else
{
OpenRCT2::FmtString fmtServerName(NetworkGetServerName());
std::string serverName;
for (const auto& token : fmtServerName)
{
if (token.IsLiteral())
{
serverName += token.text;
}
else if (token.IsCodepoint())
{
auto codepoint = token.GetCodepoint();
char buffer[8]{};
UTF8WriteCodepoint(buffer, codepoint);
serverName += buffer;
}
}
state = serverName;
partyId = NetworkGetServerName();
// NOTE: the party size is displayed next to state
discordPresence.partyId = partyId.c_str();
discordPresence.partySize = NetworkGetNumPlayers();
discordPresence.partyMax = 256;
// TODO generate secrets for the server
discordPresence.matchSecret = nullptr;
discordPresence.spectateSecret = nullptr;
discordPresence.instance = 1;
}
break;
case LegacyScene::titleSequence:
details = "In Menus";
break;
case LegacyScene::scenarioEditor:
details = "In Scenario Editor";
break;
case LegacyScene::trackDesigner:
details = "In Track Designer";
break;
case LegacyScene::trackDesignsManager:
details = "In Track Designs Manager";
break;
LOG_VERBOSE("DiscordService::OnReady()");
}
discordPresence.state = state.c_str();
discordPresence.details = details.c_str();
static void OnDisconnected(int errorCode, const char* message)
{
Console::Error::WriteLine("DiscordService::OnDisconnected(%d, %s)", errorCode, message);
}
Discord_UpdatePresence(&discordPresence);
}
static void OnErrored(int errorCode, const char* message)
{
Console::Error::WriteLine("DiscordService::OnErrored(%d, %s)", errorCode, message);
}
DiscordService::DiscordService()
{
DiscordEventHandlers handlers = {};
handlers.ready = OnReady;
handlers.disconnected = OnDisconnected;
handlers.errored = OnErrored;
Discord_Initialize(kApplicationID, &handlers, 1, kSteamAppID);
}
DiscordService::~DiscordService()
{
Discord_Shutdown();
}
static std::string GetParkName()
{
auto& gameState = getGameState();
return gameState.park.name;
}
void DiscordService::Tick()
{
Discord_RunCallbacks();
if (_updateTimer.GetElapsedTime() < kRefreshInterval)
return;
RefreshPresence();
_updateTimer.Restart();
}
void DiscordService::RefreshPresence() const
{
DiscordRichPresence discordPresence = {};
discordPresence.largeImageKey = "logo";
std::string state;
std::string details;
std::string partyId;
switch (gLegacyScene)
{
default:
details = GetParkName();
if (NetworkGetMode() == NETWORK_MODE_NONE)
{
state = "Playing Solo";
}
else
{
OpenRCT2::FmtString fmtServerName(NetworkGetServerName());
std::string serverName;
for (const auto& token : fmtServerName)
{
if (token.IsLiteral())
{
serverName += token.text;
}
else if (token.IsCodepoint())
{
auto codepoint = token.GetCodepoint();
char buffer[8]{};
UTF8WriteCodepoint(buffer, codepoint);
serverName += buffer;
}
}
state = serverName;
partyId = NetworkGetServerName();
// NOTE: the party size is displayed next to state
discordPresence.partyId = partyId.c_str();
discordPresence.partySize = NetworkGetNumPlayers();
discordPresence.partyMax = 256;
// TODO generate secrets for the server
discordPresence.matchSecret = nullptr;
discordPresence.spectateSecret = nullptr;
discordPresence.instance = 1;
}
break;
case LegacyScene::titleSequence:
details = "In Menus";
break;
case LegacyScene::scenarioEditor:
details = "In Scenario Editor";
break;
case LegacyScene::trackDesigner:
details = "In Track Designer";
break;
case LegacyScene::trackDesignsManager:
details = "In Track Designs Manager";
break;
}
discordPresence.state = state.c_str();
discordPresence.details = details.c_str();
Discord_UpdatePresence(&discordPresence);
}
} // namespace OpenRCT2::Network
#endif

23
src/openrct2/network/DiscordService.h
View File

@@ -15,19 +15,22 @@
#include <limits>
class DiscordService final
namespace OpenRCT2::Network
{
private:
OpenRCT2::Timer _updateTimer;
class DiscordService final
{
private:
OpenRCT2::Timer _updateTimer;
public:
DiscordService();
~DiscordService();
public:
DiscordService();
~DiscordService();
void Tick();
void Tick();
private:
void RefreshPresence() const;
};
private:
void RefreshPresence() const;
};
} // namespace OpenRCT2::Network
#endif

163
src/openrct2/network/Network.h
View File

@@ -19,12 +19,6 @@
#include <string_view>
#include <vector>
constexpr uint16_t kNetworkDefaultPort = 11753;
constexpr uint16_t kNetworkLanBroadcastPort = 11754;
constexpr const char* kNetworkLanBroadcastMsg = "openrct2.server.query";
constexpr const char* kMasterServerURL = "https://servers.openrct2.io";
constexpr uint16_t kMaxServerDescriptionLength = 256;
struct Peep;
struct CoordsXYZ;
@@ -36,85 +30,94 @@ namespace OpenRCT2::GameActions
class Result;
} // namespace OpenRCT2::GameActions
enum class NetworkPermission : uint32_t;
namespace OpenRCT2::Network
{
constexpr uint16_t kNetworkDefaultPort = 11753;
constexpr uint16_t kNetworkLanBroadcastPort = 11754;
constexpr const char* kNetworkLanBroadcastMsg = "openrct2.server.query";
constexpr const char* kMasterServerURL = "https://servers.openrct2.io";
constexpr uint16_t kMaxServerDescriptionLength = 256;
void NetworkReconnect();
void NetworkShutdownClient();
int32_t NetworkBeginClient(const std::string& host, int32_t port);
int32_t NetworkBeginServer(int32_t port, const std::string& address);
enum class NetworkPermission : uint32_t;
[[nodiscard]] int32_t NetworkGetMode();
[[nodiscard]] int32_t NetworkGetStatus();
bool NetworkIsDesynchronised();
bool NetworkCheckDesynchronisation();
void NetworkRequestGamestateSnapshot();
void NetworkSendTick();
bool NetworkGamestateSnapshotsEnabled();
void NetworkUpdate();
void NetworkProcessPending();
void NetworkFlush();
void NetworkReconnect();
void NetworkShutdownClient();
int32_t NetworkBeginClient(const std::string& host, int32_t port);
int32_t NetworkBeginServer(int32_t port, const std::string& address);
[[nodiscard]] NetworkAuth NetworkGetAuthstatus();
[[nodiscard]] uint32_t NetworkGetServerTick();
[[nodiscard]] uint8_t NetworkGetCurrentPlayerId();
[[nodiscard]] int32_t NetworkGetNumPlayers();
[[nodiscard]] int32_t NetworkGetNumVisiblePlayers();
[[nodiscard]] const char* NetworkGetPlayerName(uint32_t index);
[[nodiscard]] uint32_t NetworkGetPlayerFlags(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerPing(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerID(uint32_t index);
[[nodiscard]] money64 NetworkGetPlayerMoneySpent(uint32_t index);
[[nodiscard]] std::string NetworkGetPlayerIPAddress(uint32_t id);
[[nodiscard]] std::string NetworkGetPlayerPublicKeyHash(uint32_t id);
void NetworkIncrementPlayerNumCommands(uint32_t playerIndex);
void NetworkAddPlayerMoneySpent(uint32_t index, money64 cost);
[[nodiscard]] int32_t NetworkGetPlayerLastAction(uint32_t index, int32_t time);
void NetworkSetPlayerLastAction(uint32_t index, GameCommand command);
[[nodiscard]] CoordsXYZ NetworkGetPlayerLastActionCoord(uint32_t index);
void NetworkSetPlayerLastActionCoord(uint32_t index, const CoordsXYZ& coord);
[[nodiscard]] uint32_t NetworkGetPlayerCommandsRan(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerIndex(uint32_t id);
[[nodiscard]] uint8_t NetworkGetPlayerGroup(uint32_t index);
void NetworkSetPlayerGroup(uint32_t index, uint32_t groupindex);
[[nodiscard]] int32_t NetworkGetGroupIndex(uint8_t id);
[[nodiscard]] int32_t NetworkGetCurrentPlayerGroupIndex();
[[nodiscard]] uint8_t NetworkGetGroupID(uint32_t index);
[[nodiscard]] int32_t NetworkGetNumGroups();
[[nodiscard]] const char* NetworkGetGroupName(uint32_t index);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkSetPlayerGroup(
NetworkPlayerId_t actionPlayerId, NetworkPlayerId_t playerId, uint8_t groupId, bool isExecuting);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkModifyGroups(
NetworkPlayerId_t actionPlayerId, OpenRCT2::GameActions::ModifyGroupType type, uint8_t groupId, const std::string& name,
uint32_t permissionIndex, OpenRCT2::GameActions::PermissionState permissionState, bool isExecuting);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkKickPlayer(NetworkPlayerId_t playerId, bool isExecuting);
[[nodiscard]] uint8_t NetworkGetDefaultGroup();
[[nodiscard]] int32_t NetworkGetNumActions();
[[nodiscard]] StringId NetworkGetActionNameStringID(uint32_t index);
[[nodiscard]] int32_t NetworkCanPerformAction(uint32_t groupindex, NetworkPermission index);
[[nodiscard]] int32_t NetworkCanPerformCommand(uint32_t groupindex, int32_t index);
void NetworkSetPickupPeep(uint8_t playerid, Peep* peep);
[[nodiscard]] Peep* NetworkGetPickupPeep(uint8_t playerid);
void NetworkSetPickupPeepOldX(uint8_t playerid, int32_t x);
[[nodiscard]] int32_t NetworkGetPickupPeepOldX(uint8_t playerid);
[[nodiscard]] bool NetworkIsServerPlayerInvisible();
[[nodiscard]] int32_t NetworkGetMode();
[[nodiscard]] int32_t NetworkGetStatus();
bool NetworkIsDesynchronised();
bool NetworkCheckDesynchronisation();
void NetworkRequestGamestateSnapshot();
void NetworkSendTick();
bool NetworkGamestateSnapshotsEnabled();
void NetworkUpdate();
void NetworkProcessPending();
void NetworkFlush();
void NetworkSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void NetworkSendGameAction(const OpenRCT2::GameActions::GameAction* action);
void NetworkSendPassword(const std::string& password);
[[nodiscard]] NetworkAuth NetworkGetAuthstatus();
[[nodiscard]] uint32_t NetworkGetServerTick();
[[nodiscard]] uint8_t NetworkGetCurrentPlayerId();
[[nodiscard]] int32_t NetworkGetNumPlayers();
[[nodiscard]] int32_t NetworkGetNumVisiblePlayers();
[[nodiscard]] const char* NetworkGetPlayerName(uint32_t index);
[[nodiscard]] uint32_t NetworkGetPlayerFlags(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerPing(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerID(uint32_t index);
[[nodiscard]] money64 NetworkGetPlayerMoneySpent(uint32_t index);
[[nodiscard]] std::string NetworkGetPlayerIPAddress(uint32_t id);
[[nodiscard]] std::string NetworkGetPlayerPublicKeyHash(uint32_t id);
void NetworkIncrementPlayerNumCommands(uint32_t playerIndex);
void NetworkAddPlayerMoneySpent(uint32_t index, money64 cost);
[[nodiscard]] int32_t NetworkGetPlayerLastAction(uint32_t index, int32_t time);
void NetworkSetPlayerLastAction(uint32_t index, GameCommand command);
[[nodiscard]] CoordsXYZ NetworkGetPlayerLastActionCoord(uint32_t index);
void NetworkSetPlayerLastActionCoord(uint32_t index, const CoordsXYZ& coord);
[[nodiscard]] uint32_t NetworkGetPlayerCommandsRan(uint32_t index);
[[nodiscard]] int32_t NetworkGetPlayerIndex(uint32_t id);
[[nodiscard]] uint8_t NetworkGetPlayerGroup(uint32_t index);
void NetworkSetPlayerGroup(uint32_t index, uint32_t groupindex);
[[nodiscard]] int32_t NetworkGetGroupIndex(uint8_t id);
[[nodiscard]] int32_t NetworkGetCurrentPlayerGroupIndex();
[[nodiscard]] uint8_t NetworkGetGroupID(uint32_t index);
[[nodiscard]] int32_t NetworkGetNumGroups();
[[nodiscard]] const char* NetworkGetGroupName(uint32_t index);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkSetPlayerGroup(
NetworkPlayerId_t actionPlayerId, NetworkPlayerId_t playerId, uint8_t groupId, bool isExecuting);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkModifyGroups(
NetworkPlayerId_t actionPlayerId, OpenRCT2::GameActions::ModifyGroupType type, uint8_t groupId, const std::string& name,
uint32_t permissionIndex, OpenRCT2::GameActions::PermissionState permissionState, bool isExecuting);
[[nodiscard]] OpenRCT2::GameActions::Result NetworkKickPlayer(NetworkPlayerId_t playerId, bool isExecuting);
[[nodiscard]] uint8_t NetworkGetDefaultGroup();
[[nodiscard]] int32_t NetworkGetNumActions();
[[nodiscard]] StringId NetworkGetActionNameStringID(uint32_t index);
[[nodiscard]] int32_t NetworkCanPerformAction(uint32_t groupindex, NetworkPermission index);
[[nodiscard]] int32_t NetworkCanPerformCommand(uint32_t groupindex, int32_t index);
void NetworkSetPickupPeep(uint8_t playerid, Peep* peep);
[[nodiscard]] Peep* NetworkGetPickupPeep(uint8_t playerid);
void NetworkSetPickupPeepOldX(uint8_t playerid, int32_t x);
[[nodiscard]] int32_t NetworkGetPickupPeepOldX(uint8_t playerid);
[[nodiscard]] bool NetworkIsServerPlayerInvisible();
void NetworkSetPassword(const char* password);
void NetworkSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void NetworkSendGameAction(const OpenRCT2::GameActions::GameAction* action);
void NetworkSendPassword(const std::string& password);
void NetworkAppendChatLog(std::string_view text);
void NetworkAppendServerLog(const utf8* text);
[[nodiscard]] u8string NetworkGetServerName();
[[nodiscard]] u8string NetworkGetServerDescription();
[[nodiscard]] u8string NetworkGetServerGreeting();
[[nodiscard]] u8string NetworkGetServerProviderName();
[[nodiscard]] u8string NetworkGetServerProviderEmail();
[[nodiscard]] u8string NetworkGetServerProviderWebsite();
void NetworkSetPassword(const char* password);
[[nodiscard]] std::string NetworkGetVersion();
void NetworkAppendChatLog(std::string_view text);
void NetworkAppendServerLog(const utf8* text);
[[nodiscard]] u8string NetworkGetServerName();
[[nodiscard]] u8string NetworkGetServerDescription();
[[nodiscard]] u8string NetworkGetServerGreeting();
[[nodiscard]] u8string NetworkGetServerProviderName();
[[nodiscard]] u8string NetworkGetServerProviderEmail();
[[nodiscard]] u8string NetworkGetServerProviderWebsite();
[[nodiscard]] NetworkStats NetworkGetStats();
[[nodiscard]] NetworkServerState NetworkGetServerState();
[[nodiscard]] json_t NetworkGetServerInfoAsJson();
[[nodiscard]] std::string NetworkGetVersion();
[[nodiscard]] NetworkStats NetworkGetStats();
[[nodiscard]] NetworkServerState NetworkGetServerState();
[[nodiscard]] json_t NetworkGetServerInfoAsJson();
} // namespace OpenRCT2::Network

443
src/openrct2/network/NetworkAction.cpp
View File

@@ -16,254 +16,257 @@
#include <algorithm>
NetworkPermission NetworkActions::FindCommand(GameCommand command)
namespace OpenRCT2::Network
{
auto it = std::find_if(Actions.begin(), Actions.end(), [&command](NetworkAction const& action) {
for (GameCommand currentCommand : action.Commands)
{
if (currentCommand == command)
NetworkPermission NetworkActions::FindCommand(GameCommand command)
{
auto it = std::find_if(Actions.begin(), Actions.end(), [&command](NetworkAction const& action) {
for (GameCommand currentCommand : action.Commands)
{
return true;
if (currentCommand == command)
{
return true;
}
}
return false;
});
if (it != Actions.end())
{
return static_cast<NetworkPermission>(it - Actions.begin());
}
return false;
});
if (it != Actions.end())
{
return static_cast<NetworkPermission>(it - Actions.begin());
return NetworkPermission::Count;
}
return NetworkPermission::Count;
}
NetworkPermission NetworkActions::FindCommandByPermissionName(const std::string& permission_name)
{
auto it = std::find_if(Actions.begin(), Actions.end(), [&permission_name](NetworkAction const& action) {
return action.PermissionName == permission_name;
});
if (it != Actions.end())
NetworkPermission NetworkActions::FindCommandByPermissionName(const std::string& permission_name)
{
return static_cast<NetworkPermission>(it - Actions.begin());
auto it = std::find_if(Actions.begin(), Actions.end(), [&permission_name](NetworkAction const& action) {
return action.PermissionName == permission_name;
});
if (it != Actions.end())
{
return static_cast<NetworkPermission>(it - Actions.begin());
}
return NetworkPermission::Count;
}
return NetworkPermission::Count;
}
const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> NetworkActions::Actions = {
NetworkAction{
STR_ACTION_CHAT,
"PERMISSION_CHAT",
{},
},
NetworkAction{
STR_ACTION_TERRAFORM,
"PERMISSION_TERRAFORM",
{
GameCommand::SetLandHeight,
GameCommand::RaiseLand,
GameCommand::LowerLand,
GameCommand::EditLandSmooth,
GameCommand::ChangeSurfaceStyle,
const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> NetworkActions::Actions = {
NetworkAction{
STR_ACTION_CHAT,
"PERMISSION_CHAT",
{},
},
},
NetworkAction{
STR_ACTION_SET_WATER_LEVEL,
"PERMISSION_SET_WATER_LEVEL",
{
GameCommand::SetWaterHeight,
GameCommand::RaiseWater,
GameCommand::LowerWater,
NetworkAction{
STR_ACTION_TERRAFORM,
"PERMISSION_TERRAFORM",
{
GameCommand::SetLandHeight,
GameCommand::RaiseLand,
GameCommand::LowerLand,
GameCommand::EditLandSmooth,
GameCommand::ChangeSurfaceStyle,
},
},
},
NetworkAction{
STR_ACTION_TOGGLE_PAUSE,
"PERMISSION_TOGGLE_PAUSE",
{
GameCommand::TogglePause,
NetworkAction{
STR_ACTION_SET_WATER_LEVEL,
"PERMISSION_SET_WATER_LEVEL",
{
GameCommand::SetWaterHeight,
GameCommand::RaiseWater,
GameCommand::LowerWater,
},
},
},
NetworkAction{
STR_ACTION_CREATE_RIDE,
"PERMISSION_CREATE_RIDE",
{
GameCommand::CreateRide,
NetworkAction{
STR_ACTION_TOGGLE_PAUSE,
"PERMISSION_TOGGLE_PAUSE",
{
GameCommand::TogglePause,
},
},
},
NetworkAction{
STR_ACTION_REMOVE_RIDE,
"PERMISSION_REMOVE_RIDE",
{
GameCommand::DemolishRide,
NetworkAction{
STR_ACTION_CREATE_RIDE,
"PERMISSION_CREATE_RIDE",
{
GameCommand::CreateRide,
},
},
},
NetworkAction{
STR_ACTION_BUILD_RIDE,
"PERMISSION_BUILD_RIDE",
{
GameCommand::PlaceTrack,
GameCommand::RemoveTrack,
GameCommand::SetMazeTrack,
GameCommand::PlaceTrackDesign,
GameCommand::PlaceMazeDesign,
GameCommand::PlaceRideEntranceOrExit,
GameCommand::RemoveRideEntranceOrExit,
NetworkAction{
STR_ACTION_REMOVE_RIDE,
"PERMISSION_REMOVE_RIDE",
{
GameCommand::DemolishRide,
},
},
},
NetworkAction{
STR_ACTION_RIDE_PROPERTIES,
"PERMISSION_RIDE_PROPERTIES",
{
GameCommand::SetRideName,
GameCommand::SetRideAppearance,
GameCommand::SetRideStatus,
GameCommand::SetRideVehicles,
GameCommand::SetRideSetting,
GameCommand::SetRidePrice,
GameCommand::SetBrakesSpeed,
GameCommand::SetColourScheme,
NetworkAction{
STR_ACTION_BUILD_RIDE,
"PERMISSION_BUILD_RIDE",
{
GameCommand::PlaceTrack,
GameCommand::RemoveTrack,
GameCommand::SetMazeTrack,
GameCommand::PlaceTrackDesign,
GameCommand::PlaceMazeDesign,
GameCommand::PlaceRideEntranceOrExit,
GameCommand::RemoveRideEntranceOrExit,
},
},
},
NetworkAction{
STR_ACTION_SCENERY,
"PERMISSION_SCENERY",
{
GameCommand::RemoveScenery,
GameCommand::PlaceScenery,
GameCommand::SetBrakesSpeed,
GameCommand::RemoveWall,
GameCommand::PlaceWall,
GameCommand::RemoveLargeScenery,
GameCommand::PlaceLargeScenery,
GameCommand::PlaceBanner,
GameCommand::RemoveBanner,
GameCommand::SetSceneryColour,
GameCommand::SetWallColour,
GameCommand::SetLargeSceneryColour,
GameCommand::SetBannerColour,
GameCommand::SetBannerName,
GameCommand::SetSignName,
GameCommand::SetBannerStyle,
GameCommand::SetSignStyle,
NetworkAction{
STR_ACTION_RIDE_PROPERTIES,
"PERMISSION_RIDE_PROPERTIES",
{
GameCommand::SetRideName,
GameCommand::SetRideAppearance,
GameCommand::SetRideStatus,
GameCommand::SetRideVehicles,
GameCommand::SetRideSetting,
GameCommand::SetRidePrice,
GameCommand::SetBrakesSpeed,
GameCommand::SetColourScheme,
},
},
},
NetworkAction{
STR_ACTION_PATH,
"PERMISSION_PATH",
{
GameCommand::PlacePath,
GameCommand::PlacePathLayout,
GameCommand::RemovePath,
GameCommand::PlaceFootpathAddition,
GameCommand::RemoveFootpathAddition,
NetworkAction{
STR_ACTION_SCENERY,
"PERMISSION_SCENERY",
{
GameCommand::RemoveScenery,
GameCommand::PlaceScenery,
GameCommand::SetBrakesSpeed,
GameCommand::RemoveWall,
GameCommand::PlaceWall,
GameCommand::RemoveLargeScenery,
GameCommand::PlaceLargeScenery,
GameCommand::PlaceBanner,
GameCommand::RemoveBanner,
GameCommand::SetSceneryColour,
GameCommand::SetWallColour,
GameCommand::SetLargeSceneryColour,
GameCommand::SetBannerColour,
GameCommand::SetBannerName,
GameCommand::SetSignName,
GameCommand::SetBannerStyle,
GameCommand::SetSignStyle,
},
},
},
NetworkAction{
STR_ACTION_CLEAR_LANDSCAPE,
"PERMISSION_CLEAR_LANDSCAPE",
{
GameCommand::ClearScenery,
NetworkAction{
STR_ACTION_PATH,
"PERMISSION_PATH",
{
GameCommand::PlacePath,
GameCommand::PlacePathLayout,
GameCommand::RemovePath,
GameCommand::PlaceFootpathAddition,
GameCommand::RemoveFootpathAddition,
},
},
},
NetworkAction{
STR_ACTION_GUEST,
"PERMISSION_GUEST",
{
GameCommand::SetGuestName,
GameCommand::PickupGuest,
GameCommand::BalloonPress,
GameCommand::GuestSetFlags,
NetworkAction{
STR_ACTION_CLEAR_LANDSCAPE,
"PERMISSION_CLEAR_LANDSCAPE",
{
GameCommand::ClearScenery,
},
},
},
NetworkAction{
STR_ACTION_STAFF,
"PERMISSION_STAFF",
{
GameCommand::HireNewStaffMember,
GameCommand::SetStaffPatrol,
GameCommand::FireStaffMember,
GameCommand::SetStaffOrders,
GameCommand::SetStaffCostume,
GameCommand::SetStaffColour,
GameCommand::SetStaffName,
GameCommand::PickupStaff,
NetworkAction{
STR_ACTION_GUEST,
"PERMISSION_GUEST",
{
GameCommand::SetGuestName,
GameCommand::PickupGuest,
GameCommand::BalloonPress,
GameCommand::GuestSetFlags,
},
},
},
NetworkAction{
STR_ACTION_PARK_PROPERTIES,
"PERMISSION_PARK_PROPERTIES",
{
GameCommand::SetParkName,
GameCommand::SetParkOpen,
GameCommand::SetParkEntranceFee,
GameCommand::SetLandOwnership,
GameCommand::BuyLandRights,
GameCommand::PlaceParkEntrance,
GameCommand::RemoveParkEntrance,
GameCommand::PlacePeepSpawn,
GameCommand::ChangeMapSize,
NetworkAction{
STR_ACTION_STAFF,
"PERMISSION_STAFF",
{
GameCommand::HireNewStaffMember,
GameCommand::SetStaffPatrol,
GameCommand::FireStaffMember,
GameCommand::SetStaffOrders,
GameCommand::SetStaffCostume,
GameCommand::SetStaffColour,
GameCommand::SetStaffName,
GameCommand::PickupStaff,
},
},
},
NetworkAction{
STR_ACTION_PARK_FUNDING,
"PERMISSION_PARK_FUNDING",
{
GameCommand::SetCurrentLoan,
GameCommand::SetResearchFunding,
GameCommand::StartMarketingCampaign,
NetworkAction{
STR_ACTION_PARK_PROPERTIES,
"PERMISSION_PARK_PROPERTIES",
{
GameCommand::SetParkName,
GameCommand::SetParkOpen,
GameCommand::SetParkEntranceFee,
GameCommand::SetLandOwnership,
GameCommand::BuyLandRights,
GameCommand::PlaceParkEntrance,
GameCommand::RemoveParkEntrance,
GameCommand::PlacePeepSpawn,
GameCommand::ChangeMapSize,
},
},
},
NetworkAction{
STR_ACTION_KICK_PLAYER,
"PERMISSION_KICK_PLAYER",
{
GameCommand::KickPlayer,
NetworkAction{
STR_ACTION_PARK_FUNDING,
"PERMISSION_PARK_FUNDING",
{
GameCommand::SetCurrentLoan,
GameCommand::SetResearchFunding,
GameCommand::StartMarketingCampaign,
},
},
},
NetworkAction{
STR_ACTION_MODIFY_GROUPS,
"PERMISSION_MODIFY_GROUPS",
{
GameCommand::ModifyGroups,
NetworkAction{
STR_ACTION_KICK_PLAYER,
"PERMISSION_KICK_PLAYER",
{
GameCommand::KickPlayer,
},
},
},
NetworkAction{
STR_ACTION_SET_PLAYER_GROUP,
"PERMISSION_SET_PLAYER_GROUP",
{
GameCommand::SetPlayerGroup,
NetworkAction{
STR_ACTION_MODIFY_GROUPS,
"PERMISSION_MODIFY_GROUPS",
{
GameCommand::ModifyGroups,
},
},
},
NetworkAction{
STR_ACTION_CHEAT,
"PERMISSION_CHEAT",
{
GameCommand::Cheat,
GameCommand::SetDate,
GameCommand::FreezeRideRating,
NetworkAction{
STR_ACTION_SET_PLAYER_GROUP,
"PERMISSION_SET_PLAYER_GROUP",
{
GameCommand::SetPlayerGroup,
},
},
},
NetworkAction{
STR_ACTION_TOGGLE_SCENERY_CLUSTER,
"PERMISSION_TOGGLE_SCENERY_CLUSTER",
{},
},
NetworkAction{
STR_ACTION_PASSWORDLESS_LOGIN,
"PERMISSION_PASSWORDLESS_LOGIN",
{},
},
NetworkAction{
STR_ACTION_MODIFY_TILE,
"PERMISSION_MODIFY_TILE",
{
GameCommand::ModifyTile,
NetworkAction{
STR_ACTION_CHEAT,
"PERMISSION_CHEAT",
{
GameCommand::Cheat,
GameCommand::SetDate,
GameCommand::FreezeRideRating,
},
},
},
NetworkAction{
STR_ACTION_EDIT_SCENARIO_OPTIONS,
"PERMISSION_EDIT_SCENARIO_OPTIONS",
{
GameCommand::EditScenarioOptions,
NetworkAction{
STR_ACTION_TOGGLE_SCENERY_CLUSTER,
"PERMISSION_TOGGLE_SCENERY_CLUSTER",
{},
},
},
};
NetworkAction{
STR_ACTION_PASSWORDLESS_LOGIN,
"PERMISSION_PASSWORDLESS_LOGIN",
{},
},
NetworkAction{
STR_ACTION_MODIFY_TILE,
"PERMISSION_MODIFY_TILE",
{
GameCommand::ModifyTile,
},
},
NetworkAction{
STR_ACTION_EDIT_SCENARIO_OPTIONS,
"PERMISSION_EDIT_SCENARIO_OPTIONS",
{
GameCommand::EditScenarioOptions,
},
},
};
} // namespace OpenRCT2::Network
#endif

83
src/openrct2/network/NetworkAction.h
View File

@@ -16,48 +16,51 @@
#include <string>
#include <vector>
enum class NetworkPermission : uint32_t
namespace OpenRCT2::Network
{
Chat,
Terraform,
SetWaterLevel,
TogglePause,
CreateRide,
RemoveRide,
BuildRide,
RideProperties,
Scenery,
Path,
ClearLandscape,
Guest,
Staff,
ParkProperties,
ParkFunding,
KickPlayer,
ModifyGroups,
SetPlayerGroup,
Cheat,
ToggleSceneryCluster,
PasswordlessLogin,
ModifyTile,
EditScenarioOptions,
enum class NetworkPermission : uint32_t
{
Chat,
Terraform,
SetWaterLevel,
TogglePause,
CreateRide,
RemoveRide,
BuildRide,
RideProperties,
Scenery,
Path,
ClearLandscape,
Guest,
Staff,
ParkProperties,
ParkFunding,
KickPlayer,
ModifyGroups,
SetPlayerGroup,
Cheat,
ToggleSceneryCluster,
PasswordlessLogin,
ModifyTile,
EditScenarioOptions,
Count
};
Count
};
class NetworkAction final
{
public:
StringId Name;
std::string PermissionName;
std::vector<GameCommand> Commands;
};
class NetworkAction final
{
public:
StringId Name;
std::string PermissionName;
std::vector<GameCommand> Commands;
};
class NetworkActions final
{
public:
static const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> Actions;
class NetworkActions final
{
public:
static const std::array<NetworkAction, static_cast<size_t>(NetworkPermission::Count)> Actions;
static NetworkPermission FindCommand(GameCommand command);
static NetworkPermission FindCommandByPermissionName(const std::string& permission_name);
};
static NetworkPermission FindCommand(GameCommand command);
static NetworkPermission FindCommandByPermissionName(const std::string& permission_name);
};
} // namespace OpenRCT2::Network

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

File diff suppressed because it is too large Load Diff

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

@@ -22,235 +22,239 @@ namespace OpenRCT2
struct IContext;
}
class NetworkBase : public OpenRCT2::System
namespace OpenRCT2::Network
{
public:
NetworkBase(OpenRCT2::IContext& context);
public: // Uncategorized
bool BeginServer(uint16_t port, const std::string& address);
bool BeginClient(const std::string& host, uint16_t port);
public: // Common
bool Init();
void Close();
uint32_t GetServerTick() const noexcept;
// FIXME: This is currently the wrong function to override in System, will be refactored later.
void Update() override final;
void Flush();
void ProcessPending();
void ProcessPlayerList();
auto GetPlayerIteratorByID(uint8_t id) const;
auto GetGroupIteratorByID(uint8_t id) const;
NetworkPlayer* GetPlayerByID(uint8_t id) const;
NetworkGroup* GetGroupByID(uint8_t id) const;
int32_t GetTotalNumPlayers() const noexcept;
int32_t GetNumVisiblePlayers() const noexcept;
void SetPassword(u8string_view password);
uint8_t GetDefaultGroup() const noexcept;
std::string BeginLog(const std::string& directory, const std::string& midName, const std::string& filenameFormat);
void AppendLog(std::ostream& fs, std::string_view s);
void BeginChatLog();
void AppendChatLog(std::string_view s);
void CloseChatLog();
NetworkStats GetStats() const;
json_t GetServerInfoAsJson() const;
bool ProcessConnection(NetworkConnection& connection);
void CloseConnection();
NetworkPlayer* AddPlayer(const std::string& name, const std::string& keyhash);
void ProcessPacket(NetworkConnection& connection, NetworkPacket& packet);
public: // Server
NetworkConnection* GetPlayerConnection(uint8_t id) const;
void KickPlayer(int32_t playerId);
NetworkGroup* AddGroup();
void LoadGroups();
void SetDefaultGroup(uint8_t id);
void SaveGroups();
void RemoveGroup(uint8_t id);
uint8_t GetGroupIDByHash(const std::string& keyhash);
void BeginServerLog();
void AppendServerLog(const std::string& s);
void CloseServerLog();
void DecayCooldown(NetworkPlayer* player);
void AddClient(std::unique_ptr<ITcpSocket>&& socket);
std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey();
void SetupDefaultGroups();
void RemovePlayer(std::unique_ptr<NetworkConnection>& connection);
void UpdateServer();
void ServerClientDisconnected(std::unique_ptr<NetworkConnection>& connection);
bool SaveMap(OpenRCT2::IStream* stream, const std::vector<const OpenRCT2::ObjectRepositoryItem*>& objects) const;
std::vector<uint8_t> SaveForNetwork(const std::vector<const OpenRCT2::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 ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void ServerSendGameAction(const OpenRCT2::GameActions::GameAction* action);
void ServerSendTick();
void ServerSendPlayerInfo(int32_t playerId);
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 ServerSendEventPlayerJoined(const char* playerName);
void ServerSendEventPlayerDisconnected(const char* playerName, const char* reason);
void ServerSendObjectsList(
NetworkConnection& connection, const std::vector<const OpenRCT2::ObjectRepositoryItem*>& objects) const;
void ServerSendScripts(NetworkConnection& 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);
public: // Client
void Reconnect();
int32_t GetMode() const noexcept;
NetworkAuth GetAuthStatus();
int32_t GetStatus() const noexcept;
uint8_t GetPlayerID() const noexcept;
void ProcessPlayerInfo();
void ProcessDisconnectedClients();
static const char* FormatChat(NetworkPlayer* fromplayer, const char* text);
void SendPacketToClients(const NetworkPacket& packet, bool front = false, bool gameCmd = false) const;
bool CheckSRAND(uint32_t tick, uint32_t srand0);
bool CheckDesynchronizaton();
void RequestStateSnapshot();
bool IsDesynchronised() const noexcept;
NetworkServerState GetServerState() const noexcept;
void ServerClientDisconnected();
bool LoadMap(OpenRCT2::IStream* stream);
void UpdateClient();
// Packet dispatchers.
void Client_Send_RequestGameState(uint32_t tick);
void Client_Send_TOKEN();
void Client_Send_AUTH(
const std::string& name, const std::string& password, const std::string& pubkey, const std::vector<uint8_t>& signature);
void Client_Send_CHAT(const char* text);
void Client_Send_GAME_ACTION(const OpenRCT2::GameActions::GameAction* action);
void Client_Send_PING();
void Client_Send_GAMEINFO();
void Client_Send_MAPREQUEST(const std::vector<OpenRCT2::ObjectEntryDescriptor>& objects);
void Client_Send_HEARTBEAT(NetworkConnection& 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);
std::vector<uint8_t> _challenge;
std::map<uint32_t, OpenRCT2::GameActions::GameAction::Callback_t> _gameActionCallbacks;
NetworkKey _key;
NetworkUserManager _userManager;
public: // Public common
std::string ServerName;
std::string ServerDescription;
std::string ServerGreeting;
std::string ServerProviderName;
std::string ServerProviderEmail;
std::string ServerProviderWebsite;
std::vector<std::unique_ptr<NetworkPlayer>> player_list;
std::vector<std::unique_ptr<NetworkGroup>> group_list;
bool IsServerPlayerInvisible = false;
private: // Common Data
using CommandHandler = void (NetworkBase::*)(NetworkConnection& connection, NetworkPacket& packet);
std::vector<uint8_t> chunk_buffer;
std::ofstream _chat_log_fs;
uint32_t _lastUpdateTime = 0;
uint32_t _currentDeltaTime = 0;
int32_t mode = NETWORK_MODE_NONE;
uint8_t default_group = 0;
bool _closeLock = false;
bool _requireClose = false;
private: // Server Data
std::unordered_map<NetworkCommand, CommandHandler> server_command_handlers;
std::unique_ptr<ITcpSocket> _listenSocket;
std::unique_ptr<INetworkServerAdvertiser> _advertiser;
std::list<std::unique_ptr<NetworkConnection>> client_connection_list;
std::string _serverLogPath;
std::string _serverLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::ofstream _server_log_fs;
uint16_t listening_port = 0;
bool _playerListInvalidated = false;
private: // Client Data
struct PlayerListUpdate
class NetworkBase : public OpenRCT2::System
{
std::vector<NetworkPlayer> players;
};
public:
NetworkBase(OpenRCT2::IContext& context);
struct ServerTickData
{
uint32_t srand0;
uint32_t tick;
std::string spriteHash;
};
public: // Uncategorized
bool BeginServer(uint16_t port, const std::string& address);
bool BeginClient(const std::string& host, uint16_t port);
struct ServerScriptsData
{
uint32_t pluginCount{};
uint32_t dataSize{};
OpenRCT2::MemoryStream data;
};
public: // Common
bool Init();
void Close();
uint32_t GetServerTick() const noexcept;
// FIXME: This is currently the wrong function to override in System, will be refactored later.
void Update() override final;
void Flush();
void ProcessPending();
void ProcessPlayerList();
auto GetPlayerIteratorByID(uint8_t id) const;
auto GetGroupIteratorByID(uint8_t id) const;
NetworkPlayer* GetPlayerByID(uint8_t id) const;
NetworkGroup* GetGroupByID(uint8_t id) const;
int32_t GetTotalNumPlayers() const noexcept;
int32_t GetNumVisiblePlayers() const noexcept;
void SetPassword(u8string_view password);
uint8_t GetDefaultGroup() const noexcept;
std::string BeginLog(const std::string& directory, const std::string& midName, const std::string& filenameFormat);
void AppendLog(std::ostream& fs, std::string_view s);
void BeginChatLog();
void AppendChatLog(std::string_view s);
void CloseChatLog();
NetworkStats GetStats() const;
json_t GetServerInfoAsJson() const;
bool ProcessConnection(NetworkConnection& connection);
void CloseConnection();
NetworkPlayer* AddPlayer(const std::string& name, const std::string& keyhash);
void ProcessPacket(NetworkConnection& connection, NetworkPacket& packet);
std::unordered_map<NetworkCommand, CommandHandler> client_command_handlers;
std::unique_ptr<NetworkConnection> _serverConnection;
std::map<uint32_t, PlayerListUpdate> _pendingPlayerLists;
std::multimap<uint32_t, NetworkPlayer> _pendingPlayerInfo;
std::map<uint32_t, ServerTickData> _serverTickData;
std::vector<OpenRCT2::ObjectEntryDescriptor> _missingObjects;
std::string _host;
std::string _chatLogPath;
std::string _chatLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::string _password;
OpenRCT2::MemoryStream _serverGameState;
NetworkServerState _serverState;
uint32_t _lastSentHeartbeat = 0;
uint32_t last_ping_sent_time = 0;
uint32_t server_connect_time = 0;
uint32_t _actionId;
int32_t status = NETWORK_STATUS_NONE;
uint8_t player_id = 0;
uint16_t _port = 0;
SocketStatus _lastConnectStatus = SocketStatus::Closed;
bool _requireReconnect = false;
bool _clientMapLoaded = false;
ServerScriptsData _serverScriptsData{};
};
public: // Server
NetworkConnection* GetPlayerConnection(uint8_t id) const;
void KickPlayer(int32_t playerId);
NetworkGroup* AddGroup();
void LoadGroups();
void SetDefaultGroup(uint8_t id);
void SaveGroups();
void RemoveGroup(uint8_t id);
uint8_t GetGroupIDByHash(const std::string& keyhash);
void BeginServerLog();
void AppendServerLog(const std::string& s);
void CloseServerLog();
void DecayCooldown(NetworkPlayer* player);
void AddClient(std::unique_ptr<ITcpSocket>&& socket);
std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey();
void SetupDefaultGroups();
void RemovePlayer(std::unique_ptr<NetworkConnection>& connection);
void UpdateServer();
void ServerClientDisconnected(std::unique_ptr<NetworkConnection>& connection);
bool SaveMap(OpenRCT2::IStream* stream, const std::vector<const OpenRCT2::ObjectRepositoryItem*>& objects) const;
std::vector<uint8_t> SaveForNetwork(const std::vector<const OpenRCT2::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 ServerSendChat(const char* text, const std::vector<uint8_t>& playerIds = {});
void ServerSendGameAction(const OpenRCT2::GameActions::GameAction* action);
void ServerSendTick();
void ServerSendPlayerInfo(int32_t playerId);
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 ServerSendEventPlayerJoined(const char* playerName);
void ServerSendEventPlayerDisconnected(const char* playerName, const char* reason);
void ServerSendObjectsList(
NetworkConnection& connection, const std::vector<const OpenRCT2::ObjectRepositoryItem*>& objects) const;
void ServerSendScripts(NetworkConnection& 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);
public: // Client
void Reconnect();
int32_t GetMode() const noexcept;
NetworkAuth GetAuthStatus();
int32_t GetStatus() const noexcept;
uint8_t GetPlayerID() const noexcept;
void ProcessPlayerInfo();
void ProcessDisconnectedClients();
static const char* FormatChat(NetworkPlayer* fromplayer, const char* text);
void SendPacketToClients(const NetworkPacket& packet, bool front = false, bool gameCmd = false) const;
bool CheckSRAND(uint32_t tick, uint32_t srand0);
bool CheckDesynchronizaton();
void RequestStateSnapshot();
bool IsDesynchronised() const noexcept;
NetworkServerState GetServerState() const noexcept;
void ServerClientDisconnected();
bool LoadMap(OpenRCT2::IStream* stream);
void UpdateClient();
// Packet dispatchers.
void Client_Send_RequestGameState(uint32_t tick);
void Client_Send_TOKEN();
void Client_Send_AUTH(
const std::string& name, const std::string& password, const std::string& pubkey,
const std::vector<uint8_t>& signature);
void Client_Send_CHAT(const char* text);
void Client_Send_GAME_ACTION(const OpenRCT2::GameActions::GameAction* action);
void Client_Send_PING();
void Client_Send_GAMEINFO();
void Client_Send_MAPREQUEST(const std::vector<OpenRCT2::ObjectEntryDescriptor>& objects);
void Client_Send_HEARTBEAT(NetworkConnection& 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);
std::vector<uint8_t> _challenge;
std::map<uint32_t, OpenRCT2::GameActions::GameAction::Callback_t> _gameActionCallbacks;
NetworkKey _key;
NetworkUserManager _userManager;
public: // Public common
std::string ServerName;
std::string ServerDescription;
std::string ServerGreeting;
std::string ServerProviderName;
std::string ServerProviderEmail;
std::string ServerProviderWebsite;
std::vector<std::unique_ptr<NetworkPlayer>> player_list;
std::vector<std::unique_ptr<NetworkGroup>> group_list;
bool IsServerPlayerInvisible = false;
private: // Common Data
using CommandHandler = void (NetworkBase::*)(NetworkConnection& connection, NetworkPacket& packet);
std::vector<uint8_t> chunk_buffer;
std::ofstream _chat_log_fs;
uint32_t _lastUpdateTime = 0;
uint32_t _currentDeltaTime = 0;
int32_t mode = NETWORK_MODE_NONE;
uint8_t default_group = 0;
bool _closeLock = false;
bool _requireClose = false;
private: // Server Data
std::unordered_map<NetworkCommand, CommandHandler> server_command_handlers;
std::unique_ptr<ITcpSocket> _listenSocket;
std::unique_ptr<INetworkServerAdvertiser> _advertiser;
std::list<std::unique_ptr<NetworkConnection>> client_connection_list;
std::string _serverLogPath;
std::string _serverLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::ofstream _server_log_fs;
uint16_t listening_port = 0;
bool _playerListInvalidated = false;
private: // Client Data
struct PlayerListUpdate
{
std::vector<NetworkPlayer> players;
};
struct ServerTickData
{
uint32_t srand0;
uint32_t tick;
std::string spriteHash;
};
struct ServerScriptsData
{
uint32_t pluginCount{};
uint32_t dataSize{};
OpenRCT2::MemoryStream data;
};
std::unordered_map<NetworkCommand, CommandHandler> client_command_handlers;
std::unique_ptr<NetworkConnection> _serverConnection;
std::map<uint32_t, PlayerListUpdate> _pendingPlayerLists;
std::multimap<uint32_t, NetworkPlayer> _pendingPlayerInfo;
std::map<uint32_t, ServerTickData> _serverTickData;
std::vector<OpenRCT2::ObjectEntryDescriptor> _missingObjects;
std::string _host;
std::string _chatLogPath;
std::string _chatLogFilenameFormat = "%Y%m%d-%H%M%S.txt";
std::string _password;
OpenRCT2::MemoryStream _serverGameState;
NetworkServerState _serverState;
uint32_t _lastSentHeartbeat = 0;
uint32_t last_ping_sent_time = 0;
uint32_t server_connect_time = 0;
uint32_t _actionId;
int32_t status = NETWORK_STATUS_NONE;
uint8_t player_id = 0;
uint16_t _port = 0;
SocketStatus _lastConnectStatus = SocketStatus::Closed;
bool _requireReconnect = false;
bool _clientMapLoaded = false;
ServerScriptsData _serverScriptsData{};
};
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

9
src/openrct2/network/NetworkClient.h
View File

@@ -4,9 +4,12 @@
#ifndef DISABLE_NETWORK
class NetworkClient final : public NetworkBase
namespace OpenRCT2::Network
{
public:
};
class NetworkClient final : public NetworkBase
{
public:
};
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

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

@@ -19,217 +19,218 @@
#include <sfl/small_vector.hpp>
using namespace OpenRCT2;
static constexpr size_t kNetworkDisconnectReasonBufSize = 256;
static constexpr size_t kNetworkBufferSize = (1024 * 64) - 1; // 64 KiB, maximum packet size.
namespace OpenRCT2::Network
{
static constexpr size_t kNetworkDisconnectReasonBufSize = 256;
static constexpr size_t kNetworkBufferSize = (1024 * 64) - 1; // 64 KiB, maximum packet size.
#ifndef DEBUG
static constexpr size_t kNetworkNoDataTimeout = 20; // Seconds.
static constexpr size_t kNetworkNoDataTimeout = 20; // Seconds.
#endif
static_assert(kNetworkBufferSize <= std::numeric_limits<uint16_t>::max(), "kNetworkBufferSize too big, uint16_t is max.");
static_assert(kNetworkBufferSize <= std::numeric_limits<uint16_t>::max(), "kNetworkBufferSize too big, uint16_t is max.");
NetworkConnection::NetworkConnection() noexcept
{
ResetLastPacketTime();
}
NetworkReadPacket NetworkConnection::ReadPacket()
{
size_t bytesRead = 0;
// Read packet header.
auto& header = InboundPacket.Header;
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
NetworkConnection::NetworkConnection() noexcept
{
const size_t missingLength = sizeof(header) - InboundPacket.BytesTransferred;
uint8_t* buffer = reinterpret_cast<uint8_t*>(&InboundPacket.Header);
NetworkReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead);
if (status != NetworkReadPacket::Success)
{
return status;
}
InboundPacket.BytesTransferred += bytesRead;
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
{
// If still not enough data for header, keep waiting.
return NetworkReadPacket::MoreData;
}
// Normalise values.
header.Size = Convert::NetworkToHost(header.Size);
header.Id = ByteSwapBE(header.Id);
// NOTE: For compatibility reasons for the master server we need to remove sizeof(Header.Id) from the size.
// Previously the Id field was not part of the header rather part of the body.
header.Size -= std::min<uint16_t>(header.Size, sizeof(header.Id));
// Fall-through: Read rest of packet.
ResetLastPacketTime();
}
// Read packet body.
NetworkReadPacket NetworkConnection::ReadPacket()
{
// NOTE: BytesTransfered includes the header length, this will not underflow.
const size_t missingLength = header.Size - (InboundPacket.BytesTransferred - sizeof(header));
size_t bytesRead = 0;
uint8_t buffer[kNetworkBufferSize];
if (missingLength > 0)
// Read packet header.
auto& header = InboundPacket.Header;
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
{
NetworkReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kNetworkBufferSize), &bytesRead);
const size_t missingLength = sizeof(header) - InboundPacket.BytesTransferred;
uint8_t* buffer = reinterpret_cast<uint8_t*>(&InboundPacket.Header);
NetworkReadPacket status = Socket->ReceiveData(buffer, missingLength, &bytesRead);
if (status != NetworkReadPacket::Success)
{
return status;
}
InboundPacket.BytesTransferred += bytesRead;
InboundPacket.Write(buffer, bytesRead);
if (InboundPacket.BytesTransferred < sizeof(InboundPacket.Header))
{
// If still not enough data for header, keep waiting.
return NetworkReadPacket::MoreData;
}
// Normalise values.
header.Size = Convert::NetworkToHost(header.Size);
header.Id = ByteSwapBE(header.Id);
// NOTE: For compatibility reasons for the master server we need to remove sizeof(Header.Id) from the size.
// Previously the Id field was not part of the header rather part of the body.
header.Size -= std::min<uint16_t>(header.Size, sizeof(header.Id));
// Fall-through: Read rest of packet.
}
if (InboundPacket.Data.size() == header.Size)
// Read packet body.
{
// Received complete packet.
_lastPacketTime = Platform::GetTicks();
// NOTE: BytesTransfered includes the header length, this will not underflow.
const size_t missingLength = header.Size - (InboundPacket.BytesTransferred - sizeof(header));
RecordPacketStats(InboundPacket, false);
uint8_t buffer[kNetworkBufferSize];
return NetworkReadPacket::Success;
if (missingLength > 0)
{
NetworkReadPacket status = Socket->ReceiveData(buffer, std::min(missingLength, kNetworkBufferSize), &bytesRead);
if (status != NetworkReadPacket::Success)
{
return status;
}
InboundPacket.BytesTransferred += bytesRead;
InboundPacket.Write(buffer, bytesRead);
}
if (InboundPacket.Data.size() == header.Size)
{
// Received complete packet.
_lastPacketTime = Platform::GetTicks();
RecordPacketStats(InboundPacket, false);
return NetworkReadPacket::Success;
}
}
return NetworkReadPacket::MoreData;
}
static sfl::small_vector<uint8_t, 512> serializePacket(const NetworkPacket& 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.
const auto bodyLength = packet.Data.size() + sizeof(packet.Header.Id);
Guard::Assert(bodyLength <= std::numeric_limits<uint16_t>::max(), "Packet size too large");
auto header = packet.Header;
header.Size = static_cast<uint16_t>(bodyLength);
header.Size = Convert::HostToNetwork(header.Size);
header.Id = ByteSwapBE(header.Id);
sfl::small_vector<uint8_t, 512> buffer;
buffer.reserve(sizeof(header) + packet.Data.size());
buffer.insert(buffer.end(), reinterpret_cast<uint8_t*>(&header), reinterpret_cast<uint8_t*>(&header) + sizeof(header));
buffer.insert(buffer.end(), packet.Data.begin(), packet.Data.end());
return buffer;
}
void NetworkConnection::QueuePacket(const NetworkPacket& packet, bool front)
{
if (AuthStatus == NetworkAuth::Ok || !packet.CommandRequiresAuth())
{
const auto payload = serializePacket(packet);
if (front)
{
_outboundBuffer.insert(_outboundBuffer.begin(), payload.begin(), payload.end());
}
else
{
_outboundBuffer.insert(_outboundBuffer.end(), payload.begin(), payload.end());
}
RecordPacketStats(packet, true);
}
}
return NetworkReadPacket::MoreData;
}
static sfl::small_vector<uint8_t, 512> serializePacket(const NetworkPacket& 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.
const auto bodyLength = packet.Data.size() + sizeof(packet.Header.Id);
Guard::Assert(bodyLength <= std::numeric_limits<uint16_t>::max(), "Packet size too large");
auto header = packet.Header;
header.Size = static_cast<uint16_t>(bodyLength);
header.Size = Convert::HostToNetwork(header.Size);
header.Id = ByteSwapBE(header.Id);
sfl::small_vector<uint8_t, 512> buffer;
buffer.reserve(sizeof(header) + packet.Data.size());
buffer.insert(buffer.end(), reinterpret_cast<uint8_t*>(&header), reinterpret_cast<uint8_t*>(&header) + sizeof(header));
buffer.insert(buffer.end(), packet.Data.begin(), packet.Data.end());
return buffer;
}
void NetworkConnection::QueuePacket(const NetworkPacket& packet, bool front)
{
if (AuthStatus == NetworkAuth::Ok || !packet.CommandRequiresAuth())
void NetworkConnection::Disconnect() noexcept
{
const auto payload = serializePacket(packet);
if (front)
ShouldDisconnect = true;
}
bool NetworkConnection::IsValid() const
{
return !ShouldDisconnect && Socket->GetStatus() == SocketStatus::Connected;
}
void NetworkConnection::SendQueuedData()
{
if (_outboundBuffer.empty())
{
_outboundBuffer.insert(_outboundBuffer.begin(), payload.begin(), payload.end());
return;
}
const auto bytesSent = Socket->SendData(_outboundBuffer.data(), _outboundBuffer.size());
if (bytesSent > 0)
{
_outboundBuffer.erase(_outboundBuffer.begin(), _outboundBuffer.begin() + bytesSent);
}
}
void NetworkConnection::ResetLastPacketTime() noexcept
{
_lastPacketTime = Platform::GetTicks();
}
bool NetworkConnection::ReceivedPacketRecently() const noexcept
{
#ifndef DEBUG
constexpr auto kTimeoutMs = kNetworkNoDataTimeout * 1000;
if (Platform::GetTicks() > _lastPacketTime + kTimeoutMs)
{
return false;
}
#endif
return true;
}
const utf8* NetworkConnection::GetLastDisconnectReason() const noexcept
{
return this->_lastDisconnectReason.c_str();
}
void NetworkConnection::SetLastDisconnectReason(std::string_view src)
{
_lastDisconnectReason = src;
}
void NetworkConnection::SetLastDisconnectReason(const StringId string_id, void* args)
{
char buffer[kNetworkDisconnectReasonBufSize];
OpenRCT2::FormatStringLegacy(buffer, kNetworkDisconnectReasonBufSize, string_id, args);
SetLastDisconnectReason(buffer);
}
void NetworkConnection::RecordPacketStats(const NetworkPacket& packet, bool sending)
{
uint32_t packetSize = static_cast<uint32_t>(packet.BytesTransferred);
NetworkStatisticsGroup trafficGroup;
switch (packet.GetCommand())
{
case NetworkCommand::GameAction:
trafficGroup = NetworkStatisticsGroup::Commands;
break;
case NetworkCommand::Map:
trafficGroup = NetworkStatisticsGroup::MapData;
break;
default:
trafficGroup = NetworkStatisticsGroup::Base;
break;
}
if (sending)
{
Stats.bytesSent[EnumValue(trafficGroup)] += packetSize;
Stats.bytesSent[EnumValue(NetworkStatisticsGroup::Total)] += packetSize;
}
else
{
_outboundBuffer.insert(_outboundBuffer.end(), payload.begin(), payload.end());
Stats.bytesReceived[EnumValue(trafficGroup)] += packetSize;
Stats.bytesReceived[EnumValue(NetworkStatisticsGroup::Total)] += packetSize;
}
RecordPacketStats(packet, true);
}
}
void NetworkConnection::Disconnect() noexcept
{
ShouldDisconnect = true;
}
bool NetworkConnection::IsValid() const
{
return !ShouldDisconnect && Socket->GetStatus() == SocketStatus::Connected;
}
void NetworkConnection::SendQueuedData()
{
if (_outboundBuffer.empty())
{
return;
}
const auto bytesSent = Socket->SendData(_outboundBuffer.data(), _outboundBuffer.size());
if (bytesSent > 0)
{
_outboundBuffer.erase(_outboundBuffer.begin(), _outboundBuffer.begin() + bytesSent);
}
}
void NetworkConnection::ResetLastPacketTime() noexcept
{
_lastPacketTime = Platform::GetTicks();
}
bool NetworkConnection::ReceivedPacketRecently() const noexcept
{
#ifndef DEBUG
constexpr auto kTimeoutMs = kNetworkNoDataTimeout * 1000;
if (Platform::GetTicks() > _lastPacketTime + kTimeoutMs)
{
return false;
}
#endif
return true;
}
const utf8* NetworkConnection::GetLastDisconnectReason() const noexcept
{
return this->_lastDisconnectReason.c_str();
}
void NetworkConnection::SetLastDisconnectReason(std::string_view src)
{
_lastDisconnectReason = src;
}
void NetworkConnection::SetLastDisconnectReason(const StringId string_id, void* args)
{
char buffer[kNetworkDisconnectReasonBufSize];
OpenRCT2::FormatStringLegacy(buffer, kNetworkDisconnectReasonBufSize, string_id, args);
SetLastDisconnectReason(buffer);
}
void NetworkConnection::RecordPacketStats(const NetworkPacket& packet, bool sending)
{
uint32_t packetSize = static_cast<uint32_t>(packet.BytesTransferred);
NetworkStatisticsGroup trafficGroup;
switch (packet.GetCommand())
{
case NetworkCommand::GameAction:
trafficGroup = NetworkStatisticsGroup::Commands;
break;
case NetworkCommand::Map:
trafficGroup = NetworkStatisticsGroup::MapData;
break;
default:
trafficGroup = NetworkStatisticsGroup::Base;
break;
}
if (sending)
{
Stats.bytesSent[EnumValue(trafficGroup)] += packetSize;
Stats.bytesSent[EnumValue(NetworkStatisticsGroup::Total)] += packetSize;
}
else
{
Stats.bytesReceived[EnumValue(trafficGroup)] += packetSize;
Stats.bytesReceived[EnumValue(NetworkStatisticsGroup::Total)] += packetSize;
}
}
} // namespace OpenRCT2::Network
#endif

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

@@ -20,51 +20,54 @@
#include <string_view>
#include <vector>
class NetworkPlayer;
namespace OpenRCT2
{
struct ObjectRepositoryItem;
}
class NetworkConnection final
namespace OpenRCT2::Network
{
public:
std::unique_ptr<ITcpSocket> Socket = nullptr;
NetworkPacket InboundPacket;
NetworkAuth AuthStatus = NetworkAuth::None;
NetworkStats Stats = {};
NetworkPlayer* Player = nullptr;
uint32_t PingTime = 0;
NetworkKey Key;
std::vector<uint8_t> Challenge;
std::vector<const OpenRCT2::ObjectRepositoryItem*> RequestedObjects;
bool ShouldDisconnect = false;
class NetworkPlayer;
NetworkConnection() noexcept;
class NetworkConnection final
{
public:
std::unique_ptr<ITcpSocket> Socket = nullptr;
NetworkPacket InboundPacket;
NetworkAuth AuthStatus = NetworkAuth::None;
NetworkStats Stats = {};
NetworkPlayer* Player = nullptr;
uint32_t PingTime = 0;
NetworkKey Key;
std::vector<uint8_t> Challenge;
std::vector<const OpenRCT2::ObjectRepositoryItem*> RequestedObjects;
bool ShouldDisconnect = false;
NetworkReadPacket ReadPacket();
void QueuePacket(const NetworkPacket& packet, bool front = false);
NetworkConnection() noexcept;
// This will not immediately disconnect the client. The disconnect
// will happen post-tick.
void Disconnect() noexcept;
NetworkReadPacket ReadPacket();
void QueuePacket(const NetworkPacket& packet, bool front = false);
bool IsValid() const;
void SendQueuedData();
void ResetLastPacketTime() noexcept;
bool ReceivedPacketRecently() const noexcept;
// This will not immediately disconnect the client. The disconnect
// will happen post-tick.
void Disconnect() noexcept;
const utf8* GetLastDisconnectReason() const noexcept;
void SetLastDisconnectReason(std::string_view src);
void SetLastDisconnectReason(const StringId string_id, void* args = nullptr);
bool IsValid() const;
void SendQueuedData();
void ResetLastPacketTime() noexcept;
bool ReceivedPacketRecently() const noexcept;
private:
std::vector<uint8_t> _outboundBuffer;
uint32_t _lastPacketTime = 0;
std::string _lastDisconnectReason;
const utf8* GetLastDisconnectReason() const noexcept;
void SetLastDisconnectReason(std::string_view src);
void SetLastDisconnectReason(const StringId string_id, void* args = nullptr);
void RecordPacketStats(const NetworkPacket& packet, bool sending);
};
private:
std::vector<uint8_t> _outboundBuffer;
uint32_t _lastPacketTime = 0;
std::string _lastDisconnectReason;
void RecordPacketStats(const NetworkPacket& packet, bool sending);
};
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

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

@@ -15,119 +15,120 @@
#include "NetworkAction.h"
#include "NetworkTypes.h"
using namespace OpenRCT2;
NetworkGroup NetworkGroup::FromJson(const json_t& jsonData)
namespace OpenRCT2::Network
{
Guard::Assert(jsonData.is_object(), "NetworkGroup::FromJson expects parameter jsonData to be object");
NetworkGroup group;
json_t jsonId = jsonData["id"];
json_t jsonName = jsonData["name"];
json_t jsonPermissions = jsonData["permissions"];
if (jsonId.is_null() || jsonName.is_null() || jsonPermissions.is_null())
NetworkGroup NetworkGroup::FromJson(const json_t& jsonData)
{
throw std::runtime_error("Missing group data");
Guard::Assert(jsonData.is_object(), "NetworkGroup::FromJson expects parameter jsonData to be object");
NetworkGroup group;
json_t jsonId = jsonData["id"];
json_t jsonName = jsonData["name"];
json_t jsonPermissions = jsonData["permissions"];
if (jsonId.is_null() || jsonName.is_null() || jsonPermissions.is_null())
{
throw std::runtime_error("Missing group data");
}
group.Id = Json::GetNumber<uint8_t>(jsonId);
group._name = Json::GetString(jsonName);
std::fill(group.ActionsAllowed.begin(), group.ActionsAllowed.end(), 0);
for (const auto& jsonValue : jsonPermissions)
{
const std::string permission = Json::GetString(jsonValue);
NetworkPermission action_id = NetworkActions::FindCommandByPermissionName(permission);
if (action_id != NetworkPermission::Count)
{
group.ToggleActionPermission(action_id);
}
}
return group;
}
group.Id = Json::GetNumber<uint8_t>(jsonId);
group._name = Json::GetString(jsonName);
std::fill(group.ActionsAllowed.begin(), group.ActionsAllowed.end(), 0);
for (const auto& jsonValue : jsonPermissions)
json_t NetworkGroup::ToJson() const
{
const std::string permission = Json::GetString(jsonValue);
NetworkPermission action_id = NetworkActions::FindCommandByPermissionName(permission);
if (action_id != NetworkPermission::Count)
json_t jsonGroup = {
{ "id", Id },
{ "name", GetName() },
};
json_t actionsArray = json_t::array();
for (size_t i = 0; i < NetworkActions::Actions.size(); i++)
{
group.ToggleActionPermission(action_id);
if (CanPerformAction(static_cast<NetworkPermission>(i)))
{
actionsArray.emplace_back(NetworkActions::Actions[i].PermissionName);
}
}
jsonGroup["permissions"] = actionsArray;
return jsonGroup;
}
const std::string& NetworkGroup::GetName() const noexcept
{
return _name;
}
void NetworkGroup::SetName(std::string_view name)
{
_name = name;
}
void NetworkGroup::Read(NetworkPacket& packet)
{
packet >> Id;
SetName(packet.ReadString());
for (auto& action : ActionsAllowed)
{
packet >> action;
}
}
return group;
}
json_t NetworkGroup::ToJson() const
{
json_t jsonGroup = {
{ "id", Id },
{ "name", GetName() },
};
json_t actionsArray = json_t::array();
for (size_t i = 0; i < NetworkActions::Actions.size(); i++)
void NetworkGroup::Write(NetworkPacket& packet) const
{
if (CanPerformAction(static_cast<NetworkPermission>(i)))
packet << Id;
packet.WriteString(GetName().c_str());
for (const auto& action : ActionsAllowed)
{
actionsArray.emplace_back(NetworkActions::Actions[i].PermissionName);
packet << action;
}
}
jsonGroup["permissions"] = actionsArray;
return jsonGroup;
}
const std::string& NetworkGroup::GetName() const noexcept
{
return _name;
}
void NetworkGroup::SetName(std::string_view name)
{
_name = name;
}
void NetworkGroup::Read(NetworkPacket& packet)
{
packet >> Id;
SetName(packet.ReadString());
for (auto& action : ActionsAllowed)
void NetworkGroup::ToggleActionPermission(NetworkPermission index)
{
packet >> action;
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
{
return;
}
ActionsAllowed[byte] ^= (1 << bit);
}
}
void NetworkGroup::Write(NetworkPacket& packet) const
{
packet << Id;
packet.WriteString(GetName().c_str());
for (const auto& action : ActionsAllowed)
bool NetworkGroup::CanPerformAction(NetworkPermission index) const noexcept
{
packet << action;
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
{
return false;
}
return (ActionsAllowed[byte] & (1 << bit)) != 0;
}
}
void NetworkGroup::ToggleActionPermission(NetworkPermission index)
{
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
{
return;
}
ActionsAllowed[byte] ^= (1 << bit);
}
bool NetworkGroup::CanPerformAction(NetworkPermission index) const noexcept
{
size_t index_st = static_cast<size_t>(index);
size_t byte = index_st / 8;
size_t bit = index_st % 8;
if (byte >= ActionsAllowed.size())
bool NetworkGroup::CanPerformCommand(GameCommand command) const
{
NetworkPermission action = NetworkActions::FindCommand(command);
if (action != NetworkPermission::Count)
{
return CanPerformAction(action);
}
return false;
}
return (ActionsAllowed[byte] & (1 << bit)) != 0;
}
bool NetworkGroup::CanPerformCommand(GameCommand command) const
{
NetworkPermission action = NetworkActions::FindCommand(command);
if (action != NetworkPermission::Count)
{
return CanPerformAction(action);
}
return false;
}
} // namespace OpenRCT2::Network
#endif

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

@@ -16,39 +16,42 @@
#include <string>
#include <string_view>
enum class NetworkPermission : uint32_t;
class NetworkGroup final
namespace OpenRCT2::Network
{
public:
std::array<uint8_t, 8> ActionsAllowed{};
uint8_t Id = 0;
enum class NetworkPermission : uint32_t;
/**
* Creates a NetworkGroup object from a JSON object
*
* @param json JSON data source
* @return A NetworkGroup object
* @note json is deliberately left non-const: json_t behaviour changes when const
*/
static NetworkGroup FromJson(const json_t& json);
class NetworkGroup final
{
public:
std::array<uint8_t, 8> ActionsAllowed{};
uint8_t Id = 0;
const std::string& GetName() const noexcept;
void SetName(std::string_view name);
/**
* Creates a NetworkGroup object from a JSON object
*
* @param json JSON data source
* @return A NetworkGroup object
* @note json is deliberately left non-const: json_t behaviour changes when const
*/
static NetworkGroup FromJson(const json_t& json);
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet) const;
void ToggleActionPermission(NetworkPermission index);
bool CanPerformAction(NetworkPermission index) const noexcept;
bool CanPerformCommand(GameCommand command) const;
const std::string& GetName() const noexcept;
void SetName(std::string_view name);
/**
* Serialise a NetworkGroup object into a JSON object
*
* @return JSON representation of the NetworkGroup object
*/
json_t ToJson() const;
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet) const;
void ToggleActionPermission(NetworkPermission index);
bool CanPerformAction(NetworkPermission index) const noexcept;
bool CanPerformCommand(GameCommand command) const;
private:
std::string _name;
};
/**
* Serialise a NetworkGroup object into a JSON object
*
* @return JSON representation of the NetworkGroup object
*/
json_t ToJson() const;
private:
std::string _name;
};
} // namespace OpenRCT2::Network

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

@@ -19,199 +19,200 @@
#include <vector>
using namespace OpenRCT2;
NetworkKey::NetworkKey() = default;
NetworkKey::~NetworkKey() = default;
void NetworkKey::Unload()
namespace OpenRCT2::Network
{
_key = nullptr;
}
NetworkKey::NetworkKey() = default;
NetworkKey::~NetworkKey() = default;
bool NetworkKey::Generate()
{
try
void NetworkKey::Unload()
{
_key = Crypt::CreateRSAKey();
_key->Generate();
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Generate failed: %s", e.what());
return false;
}
}
bool NetworkKey::LoadPrivate(OpenRCT2::IStream* stream)
{
Guard::ArgumentNotNull(stream);
size_t size = static_cast<size_t>(stream->GetLength());
if (size == static_cast<size_t>(-1))
{
LOG_ERROR("unknown size, refusing to load key");
return false;
}
if (size > 4 * 1024 * 1024)
{
LOG_ERROR("Key file suspiciously large, refusing to load it");
return false;
_key = nullptr;
}
std::string pem(size, '\0');
stream->Read(pem.data(), pem.size());
try
bool NetworkKey::Generate()
{
_key = Crypt::CreateRSAKey();
_key->SetPrivate(pem);
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::LoadPublic(OpenRCT2::IStream* stream)
{
Guard::ArgumentNotNull(stream);
size_t size = static_cast<size_t>(stream->GetLength());
if (size == static_cast<size_t>(-1))
{
LOG_ERROR("unknown size, refusing to load key");
return false;
}
if (size > 4 * 1024 * 1024)
{
LOG_ERROR("Key file suspiciously large, refusing to load it");
return false;
try
{
_key = Crypt::CreateRSAKey();
_key->Generate();
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Generate failed: %s", e.what());
return false;
}
}
std::string pem(size, '\0');
stream->Read(pem.data(), pem.size());
try
bool NetworkKey::LoadPrivate(OpenRCT2::IStream* stream)
{
_key = Crypt::CreateRSAKey();
_key->SetPublic(pem);
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPublic failed: %s", e.what());
return false;
}
}
Guard::ArgumentNotNull(stream);
bool NetworkKey::SavePrivate(OpenRCT2::IStream* stream)
{
try
size_t size = static_cast<size_t>(stream->GetLength());
if (size == static_cast<size_t>(-1))
{
LOG_ERROR("unknown size, refusing to load key");
return false;
}
if (size > 4 * 1024 * 1024)
{
LOG_ERROR("Key file suspiciously large, refusing to load it");
return false;
}
std::string pem(size, '\0');
stream->Read(pem.data(), pem.size());
try
{
_key = Crypt::CreateRSAKey();
_key->SetPrivate(pem);
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::LoadPublic(OpenRCT2::IStream* stream)
{
Guard::ArgumentNotNull(stream);
size_t size = static_cast<size_t>(stream->GetLength());
if (size == static_cast<size_t>(-1))
{
LOG_ERROR("unknown size, refusing to load key");
return false;
}
if (size > 4 * 1024 * 1024)
{
LOG_ERROR("Key file suspiciously large, refusing to load it");
return false;
}
std::string pem(size, '\0');
stream->Read(pem.data(), pem.size());
try
{
_key = Crypt::CreateRSAKey();
_key->SetPublic(pem);
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::LoadPublic failed: %s", e.what());
return false;
}
}
bool NetworkKey::SavePrivate(OpenRCT2::IStream* stream)
{
try
{
if (_key == nullptr)
{
throw std::runtime_error("No key loaded");
}
auto pem = _key->GetPrivate();
stream->Write(pem.data(), pem.size());
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::SavePublic(OpenRCT2::IStream* stream)
{
try
{
if (_key == nullptr)
{
throw std::runtime_error("No key loaded");
}
auto pem = _key->GetPublic();
stream->Write(pem.data(), pem.size());
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePublic failed: %s", e.what());
return false;
}
}
std::string NetworkKey::PublicKeyString()
{
if (_key == nullptr)
{
throw std::runtime_error("No key loaded");
}
auto pem = _key->GetPrivate();
stream->Write(pem.data(), pem.size());
return true;
return _key->GetPublic();
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePrivate failed: %s", e.what());
return false;
}
}
bool NetworkKey::SavePublic(OpenRCT2::IStream* stream)
{
try
/**
* @brief NetworkKey::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.
*
* In particular, any of digest functions applied to a standardised key
* representation, like PEM, will be sufficient.
*
* @return returns a string containing key hash.
*/
std::string NetworkKey::PublicKeyHash()
{
if (_key == nullptr)
try
{
throw std::runtime_error("No key loaded");
std::string key = PublicKeyString();
if (key.empty())
{
throw std::runtime_error("No key found");
}
auto hash = Crypt::SHA1(key.c_str(), key.size());
return String::StringFromHex(hash);
}
auto pem = _key->GetPublic();
stream->Write(pem.data(), pem.size());
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::SavePublic failed: %s", e.what());
return false;
}
}
std::string NetworkKey::PublicKeyString()
{
if (_key == nullptr)
{
throw std::runtime_error("No key loaded");
}
return _key->GetPublic();
}
/**
* @brief NetworkKey::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.
*
* In particular, any of digest functions applied to a standardised key
* representation, like PEM, will be sufficient.
*
* @return returns a string containing key hash.
*/
std::string NetworkKey::PublicKeyHash()
{
try
{
std::string key = PublicKeyString();
if (key.empty())
catch (const std::exception& e)
{
throw std::runtime_error("No key found");
LOG_ERROR("Failed to create hash of public key: %s", e.what());
}
auto hash = Crypt::SHA1(key.c_str(), key.size());
return String::StringFromHex(hash);
return nullptr;
}
catch (const std::exception& e)
{
LOG_ERROR("Failed to create hash of public key: %s", e.what());
}
return nullptr;
}
bool NetworkKey::Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const
{
try
bool NetworkKey::Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const
{
auto rsa = Crypt::CreateRSA();
signature = rsa->SignData(*_key, md, len);
return true;
try
{
auto rsa = Crypt::CreateRSA();
signature = rsa->SignData(*_key, md, len);
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Sign failed: %s", e.what());
return false;
}
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::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
{
try
bool NetworkKey::Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const
{
auto rsa = Crypt::CreateRSA();
return rsa->VerifyData(*_key, md, len, signature.data(), signature.size());
try
{
auto rsa = Crypt::CreateRSA();
return rsa->VerifyData(*_key, md, len, signature.data(), signature.size());
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Verify failed: %s", e.what());
return false;
}
}
catch (const std::exception& e)
{
LOG_ERROR("NetworkKey::Verify failed: %s", e.what());
return false;
}
}
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

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

@@ -25,25 +25,28 @@ namespace OpenRCT2::Crypt
class RsaKey;
}
class NetworkKey final
namespace OpenRCT2::Network
{
public:
NetworkKey();
~NetworkKey();
bool Generate();
bool LoadPrivate(OpenRCT2::IStream* stream);
bool LoadPublic(OpenRCT2::IStream* stream);
bool SavePrivate(OpenRCT2::IStream* stream);
bool SavePublic(OpenRCT2::IStream* stream);
std::string PublicKeyString();
std::string PublicKeyHash();
void Unload();
bool Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const;
bool Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const;
class NetworkKey final
{
public:
NetworkKey();
~NetworkKey();
bool Generate();
bool LoadPrivate(OpenRCT2::IStream* stream);
bool LoadPublic(OpenRCT2::IStream* stream);
bool SavePrivate(OpenRCT2::IStream* stream);
bool SavePublic(OpenRCT2::IStream* stream);
std::string PublicKeyString();
std::string PublicKeyHash();
void Unload();
bool Sign(const uint8_t* md, const size_t len, std::vector<uint8_t>& signature) const;
bool Verify(const uint8_t* md, const size_t len, const std::vector<uint8_t>& signature) const;
private:
NetworkKey(const NetworkKey&) = delete;
std::unique_ptr<OpenRCT2::Crypt::RsaKey> _key;
};
private:
NetworkKey(const NetworkKey&) = delete;
std::unique_ptr<OpenRCT2::Crypt::RsaKey> _key;
};
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

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

@@ -15,97 +15,100 @@
#include <memory>
NetworkPacket::NetworkPacket(NetworkCommand id) noexcept
: Header{ 0, id }
namespace OpenRCT2::Network
{
}
uint8_t* NetworkPacket::GetData() noexcept
{
return Data.data();
}
const uint8_t* NetworkPacket::GetData() const noexcept
{
return Data.data();
}
NetworkCommand NetworkPacket::GetCommand() const noexcept
{
return Header.Id;
}
void NetworkPacket::Clear() noexcept
{
BytesTransferred = 0;
BytesRead = 0;
Data.clear();
}
bool NetworkPacket::CommandRequiresAuth() const noexcept
{
switch (GetCommand())
NetworkPacket::NetworkPacket(NetworkCommand id) noexcept
: Header{ 0, id }
{
case NetworkCommand::Ping:
case NetworkCommand::Auth:
case NetworkCommand::Token:
case NetworkCommand::GameInfo:
case NetworkCommand::ObjectsList:
case NetworkCommand::ScriptsHeader:
case NetworkCommand::ScriptsData:
case NetworkCommand::MapRequest:
case NetworkCommand::Heartbeat:
return false;
default:
return true;
}
}
void NetworkPacket::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)
{
Write(s.data(), s.size());
Data.push_back(0);
}
const uint8_t* NetworkPacket::Read(size_t size)
{
if (BytesRead + size > Data.size())
{
return nullptr;
}
const uint8_t* data = Data.data() + BytesRead;
BytesRead += size;
return data;
}
std::string_view NetworkPacket::ReadString()
{
if (BytesRead >= Data.size())
return {};
const char* str = reinterpret_cast<const char*>(Data.data() + BytesRead);
size_t stringLen = 0;
while (BytesRead < Data.size() && str[stringLen] != '\0')
uint8_t* NetworkPacket::GetData() noexcept
{
return Data.data();
}
const uint8_t* NetworkPacket::GetData() const noexcept
{
return Data.data();
}
NetworkCommand NetworkPacket::GetCommand() const noexcept
{
return Header.Id;
}
void NetworkPacket::Clear() noexcept
{
BytesTransferred = 0;
BytesRead = 0;
Data.clear();
}
bool NetworkPacket::CommandRequiresAuth() const noexcept
{
switch (GetCommand())
{
case NetworkCommand::Ping:
case NetworkCommand::Auth:
case NetworkCommand::Token:
case NetworkCommand::GameInfo:
case NetworkCommand::ObjectsList:
case NetworkCommand::ScriptsHeader:
case NetworkCommand::ScriptsData:
case NetworkCommand::MapRequest:
case NetworkCommand::Heartbeat:
return false;
default:
return true;
}
}
void NetworkPacket::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)
{
Write(s.data(), s.size());
Data.push_back(0);
}
const uint8_t* NetworkPacket::Read(size_t size)
{
if (BytesRead + size > Data.size())
{
return nullptr;
}
const uint8_t* data = Data.data() + BytesRead;
BytesRead += size;
return data;
}
std::string_view NetworkPacket::ReadString()
{
if (BytesRead >= Data.size())
return {};
const char* str = reinterpret_cast<const char*>(Data.data() + BytesRead);
size_t stringLen = 0;
while (BytesRead < Data.size() && str[stringLen] != '\0')
{
BytesRead++;
stringLen++;
}
if (str[stringLen] != '\0')
return {};
// Skip null terminator.
BytesRead++;
stringLen++;
return std::string_view(str, stringLen);
}
if (str[stringLen] != '\0')
return {};
// Skip null terminator.
BytesRead++;
return std::string_view(str, stringLen);
}
} // namespace OpenRCT2::Network
#endif

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

@@ -16,68 +16,71 @@
#include <sfl/small_vector.hpp>
#include <vector>
#pragma pack(push, 1)
struct PacketHeader
namespace OpenRCT2::Network
{
uint16_t Size = 0;
NetworkCommand Id = NetworkCommand::Invalid;
};
static_assert(sizeof(PacketHeader) == 6);
#pragma pack(push, 1)
struct PacketHeader
{
uint16_t Size = 0;
NetworkCommand Id = NetworkCommand::Invalid;
};
static_assert(sizeof(PacketHeader) == 6);
#pragma pack(pop)
struct NetworkPacket final
{
NetworkPacket() noexcept = default;
NetworkPacket(NetworkCommand id) noexcept;
uint8_t* GetData() noexcept;
const uint8_t* GetData() const noexcept;
NetworkCommand GetCommand() const noexcept;
void Clear() noexcept;
bool CommandRequiresAuth() const noexcept;
const uint8_t* Read(size_t size);
std::string_view ReadString();
void Write(const void* bytes, size_t size);
void WriteString(std::string_view s);
template<typename T>
NetworkPacket& operator>>(T& value)
struct NetworkPacket final
{
if (BytesRead + sizeof(value) > Header.Size)
NetworkPacket() noexcept = default;
NetworkPacket(NetworkCommand id) noexcept;
uint8_t* GetData() noexcept;
const uint8_t* GetData() const noexcept;
NetworkCommand GetCommand() const noexcept;
void Clear() noexcept;
bool CommandRequiresAuth() const noexcept;
const uint8_t* Read(size_t size);
std::string_view ReadString();
void Write(const void* bytes, size_t size);
void WriteString(std::string_view s);
template<typename T>
NetworkPacket& operator>>(T& value)
{
value = T{};
if (BytesRead + sizeof(value) > Header.Size)
{
value = T{};
}
else
{
T local;
std::memcpy(&local, &GetData()[BytesRead], sizeof(local));
value = ByteSwapBE(local);
BytesRead += sizeof(value);
}
return *this;
}
else
template<typename T>
NetworkPacket& operator<<(T value)
{
T local;
std::memcpy(&local, &GetData()[BytesRead], sizeof(local));
value = ByteSwapBE(local);
BytesRead += sizeof(value);
T swapped = ByteSwapBE(value);
Write(&swapped, sizeof(T));
return *this;
}
return *this;
}
template<typename T>
NetworkPacket& operator<<(T value)
{
T swapped = ByteSwapBE(value);
Write(&swapped, sizeof(T));
return *this;
}
NetworkPacket& operator<<(DataSerialiser& data)
{
Write(static_cast<const uint8_t*>(data.GetStream().GetData()), data.GetStream().GetLength());
return *this;
}
NetworkPacket& operator<<(DataSerialiser& data)
{
Write(static_cast<const uint8_t*>(data.GetStream().GetData()), data.GetStream().GetLength());
return *this;
}
public:
PacketHeader Header{};
sfl::small_vector<uint8_t, 512> Data;
size_t BytesTransferred = 0;
size_t BytesRead = 0;
};
public:
PacketHeader Header{};
sfl::small_vector<uint8_t, 512> Data;
size_t BytesTransferred = 0;
size_t BytesRead = 0;
};
} // namespace OpenRCT2::Network

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

@@ -15,39 +15,42 @@
#include "../ui/WindowManager.h"
#include "NetworkPacket.h"
void NetworkPlayer::SetName(std::string_view name)
namespace OpenRCT2::Network
{
// 36 == 31 + strlen(" #255");
Name = name.substr(0, 36);
}
void NetworkPlayer::SetName(std::string_view name)
{
// 36 == 31 + strlen(" #255");
Name = name.substr(0, 36);
}
void NetworkPlayer::Read(NetworkPacket& packet)
{
auto name = packet.ReadString();
SetName(name);
packet >> Id >> Flags >> Group >> LastAction >> LastActionCoord.x >> LastActionCoord.y >> LastActionCoord.z >> MoneySpent
>> CommandsRan;
}
void NetworkPlayer::Read(NetworkPacket& packet)
{
auto name = packet.ReadString();
SetName(name);
packet >> Id >> Flags >> Group >> LastAction >> LastActionCoord.x >> LastActionCoord.y >> LastActionCoord.z
>> MoneySpent >> CommandsRan;
}
void NetworkPlayer::Write(NetworkPacket& packet)
{
packet.WriteString(Name);
packet << Id << Flags << Group << LastAction << LastActionCoord.x << LastActionCoord.y << LastActionCoord.z << MoneySpent
<< CommandsRan;
}
void NetworkPlayer::Write(NetworkPacket& packet)
{
packet.WriteString(Name);
packet << Id << Flags << Group << LastAction << LastActionCoord.x << LastActionCoord.y << LastActionCoord.z
<< MoneySpent << CommandsRan;
}
void NetworkPlayer::IncrementNumCommands()
{
CommandsRan++;
auto* windowMgr = OpenRCT2::Ui::GetWindowManager();
windowMgr->InvalidateByNumber(WindowClass::Player, Id);
}
void NetworkPlayer::IncrementNumCommands()
{
CommandsRan++;
auto* windowMgr = OpenRCT2::Ui::GetWindowManager();
windowMgr->InvalidateByNumber(WindowClass::Player, Id);
}
void NetworkPlayer::AddMoneySpent(money64 cost)
{
MoneySpent += cost;
auto* windowMgr = OpenRCT2::Ui::GetWindowManager();
windowMgr->InvalidateByNumber(WindowClass::Player, Id);
}
void NetworkPlayer::AddMoneySpent(money64 cost)
{
MoneySpent += cost;
auto* windowMgr = OpenRCT2::Ui::GetWindowManager();
windowMgr->InvalidateByNumber(WindowClass::Player, Id);
}
} // namespace OpenRCT2::Network
#endif

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

@@ -17,34 +17,38 @@
#include <string_view>
#include <unordered_map>
struct NetworkPacket;
struct Peep;
class NetworkPlayer final
namespace OpenRCT2::Network
{
public:
uint8_t Id = 0;
std::string Name;
uint16_t Ping = 0;
uint8_t Flags = 0;
uint8_t Group = 0;
money64 MoneySpent = 0.00_GBP;
uint32_t CommandsRan = 0;
int32_t LastAction = -999;
uint32_t LastActionTime = 0;
CoordsXYZ LastActionCoord = {};
Peep* PickupPeep = nullptr;
int32_t PickupPeepOldX = kLocationNull;
std::string KeyHash;
uint32_t LastDemolishRideTime = 0;
uint32_t LastPlaceSceneryTime = 0;
std::unordered_map<GameCommand, int32_t> CooldownTime;
NetworkPlayer() noexcept = default;
struct NetworkPacket;
void SetName(std::string_view name);
class NetworkPlayer final
{
public:
uint8_t Id = 0;
std::string Name;
uint16_t Ping = 0;
uint8_t Flags = 0;
uint8_t Group = 0;
money64 MoneySpent = 0.00_GBP;
uint32_t CommandsRan = 0;
int32_t LastAction = -999;
uint32_t LastActionTime = 0;
CoordsXYZ LastActionCoord = {};
Peep* PickupPeep = nullptr;
int32_t PickupPeepOldX = kLocationNull;
std::string KeyHash;
uint32_t LastDemolishRideTime = 0;
uint32_t LastPlaceSceneryTime = 0;
std::unordered_map<GameCommand, int32_t> CooldownTime;
NetworkPlayer() noexcept = default;
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet);
void IncrementNumCommands();
void AddMoneySpent(money64 cost);
};
void SetName(std::string_view name);
void Read(NetworkPacket& packet);
void Write(NetworkPacket& packet);
void IncrementNumCommands();
void AddMoneySpent(money64 cost);
};
} // namespace OpenRCT2::Network

9
src/openrct2/network/NetworkServer.h
View File

@@ -4,9 +4,12 @@
#ifndef DISABLE_NETWORK
class NetworkServer final : public NetworkBase
namespace OpenRCT2::Network
{
public:
};
class NetworkServer final : public NetworkBase
{
public:
};
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

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

@@ -34,330 +34,331 @@
#include <random>
#include <string>
using namespace OpenRCT2;
enum class MasterServerStatus
namespace OpenRCT2::Network
{
Ok = 200,
InvalidToken = 401,
ServerNotFound = 404,
InternalError = 500
};
enum class MasterServerStatus
{
Ok = 200,
InvalidToken = 401,
ServerNotFound = 404,
InternalError = 500
};
#ifndef DISABLE_HTTP
using namespace std::chrono_literals;
constexpr int32_t kMasterServerRegisterTime = std::chrono::milliseconds(2min).count();
constexpr int32_t kMasterServerHeartbeatTime = std::chrono::milliseconds(1min).count();
using namespace std::chrono_literals;
constexpr int32_t kMasterServerRegisterTime = std::chrono::milliseconds(2min).count();
constexpr int32_t kMasterServerHeartbeatTime = std::chrono::milliseconds(1min).count();
#endif
class NetworkServerAdvertiser final : public INetworkServerAdvertiser
{
private:
uint16_t _port;
class NetworkServerAdvertiser final : public INetworkServerAdvertiser
{
private:
uint16_t _port;
std::unique_ptr<IUdpSocket> _lanListener;
uint32_t _lastListenTime{};
std::unique_ptr<IUdpSocket> _lanListener;
uint32_t _lastListenTime{};
AdvertiseStatus _status = AdvertiseStatus::unregistered;
AdvertiseStatus _status = AdvertiseStatus::unregistered;
#ifndef DISABLE_HTTP
uint32_t _lastAdvertiseTime = 0;
uint32_t _lastHeartbeatTime = 0;
uint32_t _lastAdvertiseTime = 0;
uint32_t _lastHeartbeatTime = 0;
// Our unique token for this server
std::string _token;
// Our unique token for this server
std::string _token;
// Key received from the master server
std::string _key;
// Key received from the master server
std::string _key;
// See https://github.com/OpenRCT2/OpenRCT2/issues/6277 and 4953
bool _forceIPv4 = false;
// See https://github.com/OpenRCT2/OpenRCT2/issues/6277 and 4953
bool _forceIPv4 = false;
#endif
public:
explicit NetworkServerAdvertiser(uint16_t port)
{
_port = port;
_lanListener = CreateUdpSocket();
#ifndef DISABLE_HTTP
_key = GenerateAdvertiseKey();
#endif
}
AdvertiseStatus GetStatus() const override
{
return _status;
}
void Update() override
{
UpdateLAN();
#ifndef DISABLE_HTTP
if (Config::Get().network.Advertise)
public:
explicit NetworkServerAdvertiser(uint16_t port)
{
UpdateWAN();
_port = port;
_lanListener = CreateUdpSocket();
#ifndef DISABLE_HTTP
_key = GenerateAdvertiseKey();
#endif
}
#endif
}
private:
void UpdateLAN()
{
auto ticks = Platform::GetTicks();
if (ticks > _lastListenTime + 500)
AdvertiseStatus GetStatus() const override
{
if (_lanListener->GetStatus() != SocketStatus::Listening)
return _status;
}
void Update() override
{
UpdateLAN();
#ifndef DISABLE_HTTP
if (Config::Get().network.Advertise)
{
_lanListener->Listen(kNetworkLanBroadcastPort);
UpdateWAN();
}
#endif
}
private:
void UpdateLAN()
{
auto ticks = Platform::GetTicks();
if (ticks > _lastListenTime + 500)
{
if (_lanListener->GetStatus() != SocketStatus::Listening)
{
_lanListener->Listen(kNetworkLanBroadcastPort);
}
else
{
char buffer[256]{};
size_t recievedBytes{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = _lanListener->ReceiveData(buffer, sizeof(buffer) - 1, &recievedBytes, &endpoint);
if (p == NetworkReadPacket::Success)
{
std::string sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes from %s on LAN broadcast port", recievedBytes, sender.c_str());
if (String::equals(buffer, kNetworkLanBroadcastMsg))
{
auto body = GetBroadcastJson();
auto bodyDump = body.dump();
size_t sendLen = bodyDump.size() + 1;
LOG_VERBOSE("Sending %zu bytes back to %s", sendLen, sender.c_str());
_lanListener->SendData(*endpoint, bodyDump.c_str(), sendLen);
}
}
}
_lastListenTime = ticks;
}
}
json_t GetBroadcastJson()
{
json_t root = NetworkGetServerInfoAsJson();
root["port"] = _port;
return root;
}
#ifndef DISABLE_HTTP
void UpdateWAN()
{
switch (_status)
{
case AdvertiseStatus::unregistered:
if (_lastAdvertiseTime == 0 || Platform::GetTicks() > _lastAdvertiseTime + kMasterServerRegisterTime)
{
if (_lastAdvertiseTime == 0)
{
Console::WriteLine("Registering server on master server");
}
SendRegistration(_forceIPv4);
}
break;
case AdvertiseStatus::registered:
if (Platform::GetTicks() > _lastHeartbeatTime + kMasterServerHeartbeatTime)
{
SendHeartbeat();
}
break;
// exhaust enum values to satisfy clang
case AdvertiseStatus::disabled:
break;
}
}
void SendRegistration(bool forceIPv4)
{
_lastAdvertiseTime = Platform::GetTicks();
// Send the registration request
Http::Request request;
request.url = GetMasterServerUrl();
request.method = Http::Method::POST;
request.forceIPv4 = forceIPv4;
json_t body = {
{ "key", _key },
{ "port", _port },
};
if (!Config::Get().network.AdvertiseAddress.empty())
{
body["address"] = Config::Get().network.AdvertiseAddress;
}
request.body = body.dump();
request.header["Content-Type"] = "application/json";
Http::DoAsync(request, [&](Http::Response response) -> void {
if (response.status != Http::Status::Ok)
{
Console::Error::WriteLine("Unable to connect to master server");
return;
}
json_t root = Json::FromString(response.body);
root = Json::AsObject(root);
this->OnRegistrationResponse(root);
});
}
void SendHeartbeat()
{
Http::Request request;
request.url = GetMasterServerUrl();
request.method = Http::Method::PUT;
json_t body = GetHeartbeatJson();
request.body = body.dump();
request.header["Content-Type"] = "application/json";
_lastHeartbeatTime = Platform::GetTicks();
Http::DoAsync(request, [&](Http::Response response) -> void {
if (response.status != Http::Status::Ok)
{
Console::Error::WriteLine("Unable to connect to master server");
return;
}
json_t root = Json::FromString(response.body);
root = Json::AsObject(root);
this->OnHeartbeatResponse(root);
});
}
/**
* @param jsonRoot must be of JSON type object or null
* @note jsonRoot is deliberately left non-const: json_t behaviour changes when const
*/
void OnRegistrationResponse(json_t& jsonRoot)
{
Guard::Assert(jsonRoot.is_object(), "OnRegistrationResponse expects parameter jsonRoot to be object");
auto status = Json::GetEnum<MasterServerStatus>(jsonRoot["status"], MasterServerStatus::InternalError);
if (status == MasterServerStatus::Ok)
{
Console::WriteLine("Server successfully registered on master server");
json_t jsonToken = jsonRoot["token"];
if (jsonToken.is_string())
{
_token = Json::GetString(jsonToken);
_status = AdvertiseStatus::registered;
}
}
else
{
char buffer[256]{};
size_t recievedBytes{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = _lanListener->ReceiveData(buffer, sizeof(buffer) - 1, &recievedBytes, &endpoint);
if (p == NetworkReadPacket::Success)
std::string message = Json::GetString(jsonRoot["message"]);
if (message.empty())
{
std::string sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes from %s on LAN broadcast port", recievedBytes, sender.c_str());
if (String::equals(buffer, kNetworkLanBroadcastMsg))
{
auto body = GetBroadcastJson();
auto bodyDump = body.dump();
size_t sendLen = bodyDump.size() + 1;
LOG_VERBOSE("Sending %zu bytes back to %s", sendLen, sender.c_str());
_lanListener->SendData(*endpoint, bodyDump.c_str(), sendLen);
}
message = "Invalid response from server";
}
Console::Error::WriteLine(
"Unable to advertise (%d): %s\n * Check that you have port forwarded %u\n * Try setting "
"advertise_address in config.ini",
status, message.c_str(), _port);
// Hack for https://github.com/OpenRCT2/OpenRCT2/issues/6277
// Master server may not reply correctly if using IPv6, retry forcing IPv4,
// don't wait the full timeout.
if (!_forceIPv4 && status == MasterServerStatus::InternalError)
{
_forceIPv4 = true;
_lastAdvertiseTime = 0;
LOG_INFO("Forcing HTTP(S) over IPv4");
}
}
_lastListenTime = ticks;
}
}
json_t GetBroadcastJson()
{
json_t root = NetworkGetServerInfoAsJson();
root["port"] = _port;
return root;
}
#ifndef DISABLE_HTTP
void UpdateWAN()
{
switch (_status)
{
case AdvertiseStatus::unregistered:
if (_lastAdvertiseTime == 0 || Platform::GetTicks() > _lastAdvertiseTime + kMasterServerRegisterTime)
{
if (_lastAdvertiseTime == 0)
{
Console::WriteLine("Registering server on master server");
}
SendRegistration(_forceIPv4);
}
break;
case AdvertiseStatus::registered:
if (Platform::GetTicks() > _lastHeartbeatTime + kMasterServerHeartbeatTime)
{
SendHeartbeat();
}
break;
// exhaust enum values to satisfy clang
case AdvertiseStatus::disabled:
break;
}
}
void SendRegistration(bool forceIPv4)
{
_lastAdvertiseTime = Platform::GetTicks();
// Send the registration request
Http::Request request;
request.url = GetMasterServerUrl();
request.method = Http::Method::POST;
request.forceIPv4 = forceIPv4;
json_t body = {
{ "key", _key },
{ "port", _port },
};
if (!Config::Get().network.AdvertiseAddress.empty())
{
body["address"] = Config::Get().network.AdvertiseAddress;
}
request.body = body.dump();
request.header["Content-Type"] = "application/json";
Http::DoAsync(request, [&](Http::Response response) -> void {
if (response.status != Http::Status::Ok)
{
Console::Error::WriteLine("Unable to connect to master server");
return;
}
json_t root = Json::FromString(response.body);
root = Json::AsObject(root);
this->OnRegistrationResponse(root);
});
}
void SendHeartbeat()
{
Http::Request request;
request.url = GetMasterServerUrl();
request.method = Http::Method::PUT;
json_t body = GetHeartbeatJson();
request.body = body.dump();
request.header["Content-Type"] = "application/json";
_lastHeartbeatTime = Platform::GetTicks();
Http::DoAsync(request, [&](Http::Response response) -> void {
if (response.status != Http::Status::Ok)
{
Console::Error::WriteLine("Unable to connect to master server");
return;
}
json_t root = Json::FromString(response.body);
root = Json::AsObject(root);
this->OnHeartbeatResponse(root);
});
}
/**
* @param jsonRoot must be of JSON type object or null
* @note jsonRoot is deliberately left non-const: json_t behaviour changes when const
*/
void OnRegistrationResponse(json_t& jsonRoot)
{
Guard::Assert(jsonRoot.is_object(), "OnRegistrationResponse expects parameter jsonRoot to be object");
auto status = Json::GetEnum<MasterServerStatus>(jsonRoot["status"], MasterServerStatus::InternalError);
if (status == MasterServerStatus::Ok)
/**
* @param jsonRoot must be of JSON type object or null
* @note jsonRoot is deliberately left non-const: json_t behaviour changes when const
*/
void OnHeartbeatResponse(json_t& jsonRoot)
{
Console::WriteLine("Server successfully registered on master server");
json_t jsonToken = jsonRoot["token"];
if (jsonToken.is_string())
{
_token = Json::GetString(jsonToken);
_status = AdvertiseStatus::registered;
}
}
else
{
std::string message = Json::GetString(jsonRoot["message"]);
if (message.empty())
{
message = "Invalid response from server";
}
Console::Error::WriteLine(
"Unable to advertise (%d): %s\n * Check that you have port forwarded %u\n * Try setting "
"advertise_address in config.ini",
status, message.c_str(), _port);
Guard::Assert(jsonRoot.is_object(), "OnHeartbeatResponse expects parameter jsonRoot to be object");
// Hack for https://github.com/OpenRCT2/OpenRCT2/issues/6277
// Master server may not reply correctly if using IPv6, retry forcing IPv4,
// don't wait the full timeout.
if (!_forceIPv4 && status == MasterServerStatus::InternalError)
auto status = Json::GetEnum<MasterServerStatus>(jsonRoot["status"], MasterServerStatus::InternalError);
if (status == MasterServerStatus::Ok)
{
_forceIPv4 = true;
// Master server has successfully updated our server status
}
else if (status == MasterServerStatus::InvalidToken)
{
_status = AdvertiseStatus::unregistered;
_lastAdvertiseTime = 0;
LOG_INFO("Forcing HTTP(S) over IPv4");
Console::Error::WriteLine("Master server heartbeat failed: Invalid Token");
}
}
}
/**
* @param jsonRoot must be of JSON type object or null
* @note jsonRoot is deliberately left non-const: json_t behaviour changes when const
*/
void OnHeartbeatResponse(json_t& jsonRoot)
{
Guard::Assert(jsonRoot.is_object(), "OnHeartbeatResponse expects parameter jsonRoot to be object");
auto status = Json::GetEnum<MasterServerStatus>(jsonRoot["status"], MasterServerStatus::InternalError);
if (status == MasterServerStatus::Ok)
json_t GetHeartbeatJson()
{
// Master server has successfully updated our server status
}
else if (status == MasterServerStatus::InvalidToken)
{
_status = AdvertiseStatus::unregistered;
_lastAdvertiseTime = 0;
Console::Error::WriteLine("Master server heartbeat failed: Invalid Token");
}
}
uint32_t numPlayers = NetworkGetNumVisiblePlayers();
json_t GetHeartbeatJson()
{
uint32_t numPlayers = NetworkGetNumVisiblePlayers();
json_t root = {
{ "token", _token },
{ "players", numPlayers },
};
json_t root = {
{ "token", _token },
{ "players", numPlayers },
};
const auto& gameState = getGameState();
const auto& date = GetDate();
json_t mapSize = { { "x", gameState.mapSize.x - 2 }, { "y", gameState.mapSize.y - 2 } };
json_t gameInfo = {
{ "mapSize", mapSize },
{ "day", date.GetMonthTicks() },
{ "month", date.GetMonthsElapsed() },
{ "guests", gameState.park.numGuestsInPark },
{ "parkValue", gameState.park.value },
};
const auto& gameState = getGameState();
const auto& date = GetDate();
json_t mapSize = { { "x", gameState.mapSize.x - 2 }, { "y", gameState.mapSize.y - 2 } };
json_t gameInfo = {
{ "mapSize", mapSize },
{ "day", date.GetMonthTicks() },
{ "month", date.GetMonthsElapsed() },
{ "guests", gameState.park.numGuestsInPark },
{ "parkValue", gameState.park.value },
};
if (!(gameState.park.flags & PARK_FLAGS_NO_MONEY))
{
gameInfo["cash"] = gameState.park.cash;
}
if (!(gameState.park.flags & PARK_FLAGS_NO_MONEY))
{
gameInfo["cash"] = gameState.park.cash;
root["gameInfo"] = gameInfo;
return root;
}
root["gameInfo"] = gameInfo;
return root;
}
static std::string GenerateAdvertiseKey()
{
// Generate a string of 16 random hex characters (64-integer key as a hex formatted string)
static constexpr char hexChars[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
};
std::random_device rd;
std::uniform_int_distribution<int32_t> dist(0, static_cast<int32_t>(std::size(hexChars) - 1));
char key[17];
for (int32_t i = 0; i < 16; i++)
static std::string GenerateAdvertiseKey()
{
int32_t hexCharIndex = dist(rd);
key[i] = hexChars[hexCharIndex];
}
key[std::size(key) - 1] = 0;
return key;
}
// Generate a string of 16 random hex characters (64-integer key as a hex formatted string)
static constexpr char hexChars[] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
};
static std::string GetMasterServerUrl()
{
std::string result = kMasterServerURL;
if (!Config::Get().network.MasterServerUrl.empty())
{
result = Config::Get().network.MasterServerUrl;
std::random_device rd;
std::uniform_int_distribution<int32_t> dist(0, static_cast<int32_t>(std::size(hexChars) - 1));
char key[17];
for (int32_t i = 0; i < 16; i++)
{
int32_t hexCharIndex = dist(rd);
key[i] = hexChars[hexCharIndex];
}
key[std::size(key) - 1] = 0;
return key;
}
static std::string GetMasterServerUrl()
{
std::string result = kMasterServerURL;
if (!Config::Get().network.MasterServerUrl.empty())
{
result = Config::Get().network.MasterServerUrl;
}
return result;
}
return result;
}
#endif
};
};
std::unique_ptr<INetworkServerAdvertiser> CreateServerAdvertiser(uint16_t port)
{
return std::make_unique<NetworkServerAdvertiser>(port);
}
std::unique_ptr<INetworkServerAdvertiser> CreateServerAdvertiser(uint16_t port)
{
return std::make_unique<NetworkServerAdvertiser>(port);
}
} // namespace OpenRCT2::Network
#endif // DISABLE_NETWORK

31
src/openrct2/network/NetworkServerAdvertiser.h
View File

@@ -11,21 +11,24 @@
#include <memory>
enum class AdvertiseStatus
namespace OpenRCT2::Network
{
disabled,
unregistered,
registered,
};
struct INetworkServerAdvertiser
{
virtual ~INetworkServerAdvertiser()
enum class AdvertiseStatus
{
}
disabled,
unregistered,
registered,
};
virtual AdvertiseStatus GetStatus() const = 0;
virtual void Update() = 0;
};
struct INetworkServerAdvertiser
{
virtual ~INetworkServerAdvertiser()
{
}
[[nodiscard]] std::unique_ptr<INetworkServerAdvertiser> CreateServerAdvertiser(uint16_t port);
virtual AdvertiseStatus GetStatus() const = 0;
virtual void Update() = 0;
};
[[nodiscard]] std::unique_ptr<INetworkServerAdvertiser> CreateServerAdvertiser(uint16_t port);
} // namespace OpenRCT2::Network

229
src/openrct2/network/NetworkTypes.h
View File

@@ -13,136 +13,139 @@
#include "../core/EnumUtils.hpp"
#include "../ride/RideTypes.h"
enum
namespace OpenRCT2::Network
{
SERVER_EVENT_PLAYER_JOINED,
SERVER_EVENT_PLAYER_DISCONNECTED,
};
enum
{
SERVER_EVENT_PLAYER_JOINED,
SERVER_EVENT_PLAYER_DISCONNECTED,
};
enum
{
NETWORK_TICK_FLAG_CHECKSUMS = 1 << 0,
};
enum
{
NETWORK_TICK_FLAG_CHECKSUMS = 1 << 0,
};
enum
{
NETWORK_MODE_NONE,
NETWORK_MODE_CLIENT,
NETWORK_MODE_SERVER
};
enum
{
NETWORK_MODE_NONE,
NETWORK_MODE_CLIENT,
NETWORK_MODE_SERVER
};
enum
{
NETWORK_PLAYER_FLAG_ISSERVER = 1 << 0,
};
enum
{
NETWORK_PLAYER_FLAG_ISSERVER = 1 << 0,
};
enum
{
NETWORK_STATUS_NONE,
NETWORK_STATUS_READY,
NETWORK_STATUS_CONNECTING,
NETWORK_STATUS_CONNECTED
};
enum
{
NETWORK_STATUS_NONE,
NETWORK_STATUS_READY,
NETWORK_STATUS_CONNECTING,
NETWORK_STATUS_CONNECTED
};
enum class NetworkAuth : int32_t
{
None,
Requested,
Ok,
BadVersion,
BadName,
BadPassword,
VerificationFailure,
Full,
RequirePassword,
Verified,
UnknownKeyDisallowed
};
enum class NetworkAuth : int32_t
{
None,
Requested,
Ok,
BadVersion,
BadName,
BadPassword,
VerificationFailure,
Full,
RequirePassword,
Verified,
UnknownKeyDisallowed
};
enum class NetworkCommand : uint32_t
{
Auth,
Map,
Chat,
Tick = 4,
PlayerList,
Ping,
PingList,
DisconnectMessage,
GameInfo,
ShowError,
GroupList,
Event,
Token,
ObjectsList,
MapRequest,
GameAction,
PlayerInfo,
RequestGameState,
GameState,
ScriptsHeader,
ScriptsData,
Heartbeat,
Max,
Invalid = static_cast<uint32_t>(-1),
};
enum class NetworkCommand : uint32_t
{
Auth,
Map,
Chat,
Tick = 4,
PlayerList,
Ping,
PingList,
DisconnectMessage,
GameInfo,
ShowError,
GroupList,
Event,
Token,
ObjectsList,
MapRequest,
GameAction,
PlayerInfo,
RequestGameState,
GameState,
ScriptsHeader,
ScriptsData,
Heartbeat,
Max,
Invalid = static_cast<uint32_t>(-1),
};
static_assert(NetworkCommand::GameInfo == static_cast<NetworkCommand>(9), "Master server expects this to be 9");
static_assert(NetworkCommand::GameInfo == static_cast<NetworkCommand>(9), "Master server expects this to be 9");
enum class NetworkServerStatus
{
Ok,
Desynced
};
enum class NetworkServerStatus
{
Ok,
Desynced
};
struct NetworkServerState
{
NetworkServerStatus state = NetworkServerStatus::Ok;
uint32_t desyncTick = 0;
uint32_t tick = 0;
uint32_t srand0 = 0;
bool gamestateSnapshotsEnabled = false;
};
struct NetworkServerState
{
NetworkServerStatus state = NetworkServerStatus::Ok;
uint32_t desyncTick = 0;
uint32_t tick = 0;
uint32_t srand0 = 0;
bool gamestateSnapshotsEnabled = false;
};
// Structure is used for networking specific fields with meaning,
// this structure can be used in combination with DataSerialiser
// to provide extra details with template specialization.
#pragma pack(push, 1)
template<typename T, size_t _TypeID>
struct NetworkObjectId
{
NetworkObjectId(T v)
: id(v)
template<typename T, size_t _TypeID>
struct NetworkObjectId
{
}
NetworkObjectId()
: id(T(-1))
{
}
operator T() const
{
return id;
}
T id;
};
NetworkObjectId(T v)
: id(v)
{
}
NetworkObjectId()
: id(T(-1))
{
}
operator T() const
{
return id;
}
T id;
};
#pragma pack(pop)
// NOTE: When adding new types make sure to have no duplicate _TypeID's otherwise
// there is no way to specialize templates if they have the exact symbol.
using NetworkPlayerId_t = NetworkObjectId<int32_t, 0>;
using NetworkCheatType_t = NetworkObjectId<int32_t, 2>;
// NOTE: When adding new types make sure to have no duplicate _TypeID's otherwise
// there is no way to specialize templates if they have the exact symbol.
using NetworkPlayerId_t = NetworkObjectId<int32_t, 0>;
using NetworkCheatType_t = NetworkObjectId<int32_t, 2>;
enum class NetworkStatisticsGroup : uint32_t
{
Total = 0, // Entire network traffic.
Base, // Messages such as Tick, Ping
Commands, // Command / Game actions
MapData,
Max,
};
enum class NetworkStatisticsGroup : uint32_t
{
Total = 0, // Entire network traffic.
Base, // Messages such as Tick, Ping
Commands, // Command / Game actions
MapData,
Max,
};
struct NetworkStats
{
uint64_t bytesReceived[EnumValue(NetworkStatisticsGroup::Max)];
uint64_t bytesSent[EnumValue(NetworkStatisticsGroup::Max)];
};
struct NetworkStats
{
uint64_t bytesReceived[EnumValue(NetworkStatisticsGroup::Max)];
uint64_t bytesSent[EnumValue(NetworkStatisticsGroup::Max)];
};
} // namespace OpenRCT2::Network

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

@@ -22,198 +22,199 @@
#include <unordered_set>
using namespace OpenRCT2;
constexpr const utf8* kUserStoreFilename = "users.json";
std::unique_ptr<NetworkUser> NetworkUser::FromJson(const json_t& jsonData)
namespace OpenRCT2::Network
{
Guard::Assert(jsonData.is_object(), "NetworkUser::FromJson expects parameter jsonData to be object");
constexpr const utf8* kUserStoreFilename = "users.json";
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;
if (!hash.empty() && !name.empty())
std::unique_ptr<NetworkUser> NetworkUser::FromJson(const json_t& jsonData)
{
user = std::make_unique<NetworkUser>();
user->Hash = hash;
user->Name = name;
if (jsonGroupId.is_number_integer())
Guard::Assert(jsonData.is_object(), "NetworkUser::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;
if (!hash.empty() && !name.empty())
{
user->GroupId = Json::GetNumber<uint8_t>(jsonGroupId);
}
user->Remove = false;
}
return user;
}
json_t NetworkUser::ToJson() const
{
json_t jsonData;
jsonData["hash"] = Hash;
jsonData["name"] = Name;
json_t jsonGroupId;
if (GroupId.has_value())
{
jsonGroupId = *GroupId;
}
jsonData["groupId"] = jsonGroupId;
return jsonData;
}
void NetworkUserManager::Load()
{
const auto path = GetStorePath();
if (File::Exists(path))
{
_usersByHash.clear();
try
{
json_t jsonUsers = Json::ReadFromFile(path);
for (const auto& jsonUser : jsonUsers)
user = std::make_unique<NetworkUser>();
user->Hash = hash;
user->Name = name;
if (jsonGroupId.is_number_integer())
{
if (jsonUser.is_object())
user->GroupId = Json::GetNumber<uint8_t>(jsonGroupId);
}
user->Remove = false;
}
return user;
}
json_t NetworkUser::ToJson() const
{
json_t jsonData;
jsonData["hash"] = Hash;
jsonData["name"] = Name;
json_t jsonGroupId;
if (GroupId.has_value())
{
jsonGroupId = *GroupId;
}
jsonData["groupId"] = jsonGroupId;
return jsonData;
}
void NetworkUserManager::Load()
{
const auto path = GetStorePath();
if (File::Exists(path))
{
_usersByHash.clear();
try
{
json_t jsonUsers = Json::ReadFromFile(path);
for (const auto& jsonUser : jsonUsers)
{
auto networkUser = NetworkUser::FromJson(jsonUser);
if (networkUser != nullptr)
if (jsonUser.is_object())
{
_usersByHash[networkUser->Hash] = std::move(networkUser);
auto networkUser = NetworkUser::FromJson(jsonUser);
if (networkUser != nullptr)
{
_usersByHash[networkUser->Hash] = std::move(networkUser);
}
}
}
}
}
catch (const std::exception& ex)
{
Console::Error::WriteLine("Failed to read %s as JSON. %s", path.c_str(), ex.what());
}
}
}
void NetworkUserManager::Save()
{
const auto path = GetStorePath();
json_t jsonUsers;
try
{
if (File::Exists(path))
{
jsonUsers = Json::ReadFromFile(path);
}
}
catch (const std::exception&)
{
}
// Update existing users
std::unordered_set<std::string> savedHashes;
for (auto it = jsonUsers.begin(); it != jsonUsers.end();)
{
json_t jsonUser = *it;
if (!jsonUser.is_object())
{
continue;
}
std::string hashString = Json::GetString(jsonUser["hash"]);
const auto networkUser = GetUserByHash(hashString);
if (networkUser != nullptr)
{
if (networkUser->Remove)
catch (const std::exception& ex)
{
Console::Error::WriteLine("Failed to read %s as JSON. %s", path.c_str(), ex.what());
}
}
}
void NetworkUserManager::Save()
{
const auto path = GetStorePath();
json_t jsonUsers;
try
{
if (File::Exists(path))
{
jsonUsers = Json::ReadFromFile(path);
}
}
catch (const std::exception&)
{
}
// Update existing users
std::unordered_set<std::string> savedHashes;
for (auto it = jsonUsers.begin(); it != jsonUsers.end();)
{
json_t jsonUser = *it;
if (!jsonUser.is_object())
{
it = jsonUsers.erase(it);
// erase advances the iterator so make sure we don't do it again
continue;
}
std::string hashString = Json::GetString(jsonUser["hash"]);
// replace the existing element in jsonUsers
*it = networkUser->ToJson();
savedHashes.insert(hashString);
const auto networkUser = GetUserByHash(hashString);
if (networkUser != nullptr)
{
if (networkUser->Remove)
{
it = jsonUsers.erase(it);
// erase advances the iterator so make sure we don't do it again
continue;
}
// replace the existing element in jsonUsers
*it = networkUser->ToJson();
savedHashes.insert(hashString);
}
it++;
}
it++;
}
// Add new users
for (const auto& kvp : _usersByHash)
{
const auto& networkUser = kvp.second;
if (!networkUser->Remove && savedHashes.find(networkUser->Hash) == savedHashes.end())
// Add new users
for (const auto& kvp : _usersByHash)
{
jsonUsers.push_back(networkUser->ToJson());
const auto& networkUser = kvp.second;
if (!networkUser->Remove && savedHashes.find(networkUser->Hash) == savedHashes.end())
{
jsonUsers.push_back(networkUser->ToJson());
}
}
Json::WriteToFile(path, jsonUsers);
}
Json::WriteToFile(path, jsonUsers);
}
void NetworkUserManager::UnsetUsersOfGroup(uint8_t groupId)
{
for (const auto& kvp : _usersByHash)
void NetworkUserManager::UnsetUsersOfGroup(uint8_t groupId)
{
auto& networkUser = kvp.second;
if (networkUser->GroupId.has_value() && *networkUser->GroupId == groupId)
for (const auto& kvp : _usersByHash)
{
networkUser->GroupId = std::nullopt;
auto& networkUser = kvp.second;
if (networkUser->GroupId.has_value() && *networkUser->GroupId == groupId)
{
networkUser->GroupId = std::nullopt;
}
}
}
}
void NetworkUserManager::RemoveUser(const std::string& hash)
{
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash));
if (networkUser != nullptr)
void NetworkUserManager::RemoveUser(const std::string& hash)
{
networkUser->Remove = true;
}
}
const NetworkUser* NetworkUserManager::GetUserByHash(const std::string& hash) const
{
auto it = _usersByHash.find(hash);
if (it != _usersByHash.end())
{
return it->second.get();
}
return nullptr;
}
const NetworkUser* NetworkUserManager::GetUserByName(const std::string& name) const
{
for (const auto& kvp : _usersByHash)
{
const auto& networkUser = kvp.second;
if (String::iequals(name, networkUser->Name))
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash));
if (networkUser != nullptr)
{
return networkUser.get();
networkUser->Remove = true;
}
}
return nullptr;
}
NetworkUser* NetworkUserManager::GetOrAddUser(const std::string& hash)
{
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash));
if (networkUser == nullptr)
const NetworkUser* NetworkUserManager::GetUserByHash(const std::string& hash) const
{
auto newNetworkUser = std::make_unique<NetworkUser>();
newNetworkUser->Hash = hash;
networkUser = newNetworkUser.get();
_usersByHash[hash] = std::move(newNetworkUser);
auto it = _usersByHash.find(hash);
if (it != _usersByHash.end())
{
return it->second.get();
}
return nullptr;
}
return networkUser;
}
u8string NetworkUserManager::GetStorePath()
{
auto& env = OpenRCT2::GetContext()->GetPlatformEnvironment();
return Path::Combine(env.GetDirectoryPath(OpenRCT2::DirBase::user), kUserStoreFilename);
}
const NetworkUser* NetworkUserManager::GetUserByName(const std::string& name) const
{
for (const auto& kvp : _usersByHash)
{
const auto& networkUser = kvp.second;
if (String::iequals(name, networkUser->Name))
{
return networkUser.get();
}
}
return nullptr;
}
NetworkUser* NetworkUserManager::GetOrAddUser(const std::string& hash)
{
NetworkUser* networkUser = const_cast<NetworkUser*>(GetUserByHash(hash));
if (networkUser == nullptr)
{
auto newNetworkUser = std::make_unique<NetworkUser>();
newNetworkUser->Hash = hash;
networkUser = newNetworkUser.get();
_usersByHash[hash] = std::move(newNetworkUser);
}
return networkUser;
}
u8string NetworkUserManager::GetStorePath()
{
auto& env = OpenRCT2::GetContext()->GetPlatformEnvironment();
return Path::Combine(env.GetDirectoryPath(OpenRCT2::DirBase::user), kUserStoreFilename);
}
} // namespace OpenRCT2::Network
#endif

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

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

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

@@ -31,412 +31,415 @@
#include <numeric>
#include <optional>
using namespace OpenRCT2;
int32_t ServerListEntry::CompareTo(const ServerListEntry& other) const
namespace OpenRCT2::Network
{
const auto& a = *this;
const auto& b = other;
if (a.Favourite != b.Favourite)
int32_t ServerListEntry::CompareTo(const ServerListEntry& other) const
{
return a.Favourite ? -1 : 1;
}
const auto& a = *this;
const auto& b = other;
if (a.Local != b.Local)
{
return a.Local ? -1 : 1;
}
bool serverACompatible = a.Version == NetworkGetVersion();
bool serverBCompatible = b.Version == NetworkGetVersion();
if (serverACompatible != serverBCompatible)
{
return serverACompatible ? -1 : 1;
}
if (a.RequiresPassword != b.RequiresPassword)
{
return a.RequiresPassword ? 1 : -1;
}
if (a.Players != b.Players)
{
return a.Players > b.Players ? -1 : 1;
}
return String::compare(a.Name, b.Name, true);
}
bool ServerListEntry::IsVersionValid() const noexcept
{
return Version.empty() || Version == NetworkGetVersion();
}
std::optional<ServerListEntry> ServerListEntry::FromJson(json_t& server)
{
Guard::Assert(server.is_object(), "ServerListEntry::FromJson expects parameter server to be object");
const auto port = Json::GetNumber<int32_t>(server["port"]);
const auto name = Json::GetString(server["name"]);
const auto description = Json::GetString(server["description"]);
const auto requiresPassword = Json::GetBoolean(server["requiresPassword"]);
const auto version = Json::GetString(server["version"]);
const auto players = Json::GetNumber<uint8_t>(server["players"]);
const auto maxPlayers = Json::GetNumber<uint8_t>(server["maxPlayers"]);
std::string ip;
// if server["ip"] or server["ip"]["v4"] are values, this will throw an exception, so check first
if (server["ip"].is_object() && server["ip"]["v4"].is_array())
{
ip = Json::GetString(server["ip"]["v4"][0]);
}
if (name.empty() || version.empty())
{
LOG_VERBOSE("Cowardly refusing to add server without name or version specified.");
return std::nullopt;
}
ServerListEntry entry;
entry.Address = ip + ":" + std::to_string(port);
entry.Name = name;
entry.Description = description;
entry.Version = version;
entry.RequiresPassword = requiresPassword;
entry.Players = players;
entry.MaxPlayers = maxPlayers;
return entry;
}
void ServerList::Sort()
{
_serverEntries.erase(
std::unique(
_serverEntries.begin(), _serverEntries.end(),
[](const ServerListEntry& a, const ServerListEntry& b) {
if (a.Favourite == b.Favourite)
{
return String::iequals(a.Address, b.Address);
}
return false;
}),
_serverEntries.end());
std::sort(_serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& a, const ServerListEntry& b) {
return a.CompareTo(b) < 0;
});
}
ServerListEntry& ServerList::GetServer(size_t index)
{
return _serverEntries[index];
}
size_t ServerList::GetCount() const
{
return _serverEntries.size();
}
void ServerList::Add(const ServerListEntry& entry)
{
_serverEntries.push_back(entry);
Sort();
}
void ServerList::AddRange(const std::vector<ServerListEntry>& entries)
{
_serverEntries.insert(_serverEntries.end(), entries.begin(), entries.end());
Sort();
}
void ServerList::AddOrUpdateRange(const std::vector<ServerListEntry>& entries)
{
for (auto& existsEntry : _serverEntries)
{
auto match = std::find_if(
entries.begin(), entries.end(), [&](const ServerListEntry& entry) { return existsEntry.Address == entry.Address; });
if (match != entries.end())
if (a.Favourite != b.Favourite)
{
// Keep favourites
auto fav = existsEntry.Favourite;
existsEntry = *match;
existsEntry.Favourite = fav;
return a.Favourite ? -1 : 1;
}
if (a.Local != b.Local)
{
return a.Local ? -1 : 1;
}
bool serverACompatible = a.Version == NetworkGetVersion();
bool serverBCompatible = b.Version == NetworkGetVersion();
if (serverACompatible != serverBCompatible)
{
return serverACompatible ? -1 : 1;
}
if (a.RequiresPassword != b.RequiresPassword)
{
return a.RequiresPassword ? 1 : -1;
}
if (a.Players != b.Players)
{
return a.Players > b.Players ? -1 : 1;
}
return String::compare(a.Name, b.Name, true);
}
std::vector<ServerListEntry> newServers;
std::copy_if(entries.begin(), entries.end(), std::back_inserter(newServers), [this](const ServerListEntry& entry) {
return std::find_if(
_serverEntries.begin(), _serverEntries.end(),
[&](const ServerListEntry& existsEntry) { return existsEntry.Address == entry.Address; })
== _serverEntries.end();
});
AddRange(newServers);
}
void ServerList::Clear() noexcept
{
_serverEntries.clear();
}
std::vector<ServerListEntry> ServerList::ReadFavourites() const
{
LOG_VERBOSE("server_list_read(...)");
std::vector<ServerListEntry> entries;
try
bool ServerListEntry::IsVersionValid() const noexcept
{
auto& env = GetContext()->GetPlatformEnvironment();
auto path = env.GetFilePath(PathId::networkServers);
if (File::Exists(path))
return Version.empty() || Version == NetworkGetVersion();
}
std::optional<ServerListEntry> ServerListEntry::FromJson(json_t& server)
{
Guard::Assert(server.is_object(), "ServerListEntry::FromJson expects parameter server to be object");
const auto port = Json::GetNumber<int32_t>(server["port"]);
const auto name = Json::GetString(server["name"]);
const auto description = Json::GetString(server["description"]);
const auto requiresPassword = Json::GetBoolean(server["requiresPassword"]);
const auto version = Json::GetString(server["version"]);
const auto players = Json::GetNumber<uint8_t>(server["players"]);
const auto maxPlayers = Json::GetNumber<uint8_t>(server["maxPlayers"]);
std::string ip;
// if server["ip"] or server["ip"]["v4"] are values, this will throw an exception, so check first
if (server["ip"].is_object() && server["ip"]["v4"].is_array())
{
auto fs = FileStream(path, FileMode::open);
auto numEntries = fs.ReadValue<uint32_t>();
for (size_t i = 0; i < numEntries; i++)
ip = Json::GetString(server["ip"]["v4"][0]);
}
if (name.empty() || version.empty())
{
LOG_VERBOSE("Cowardly refusing to add server without name or version specified.");
return std::nullopt;
}
ServerListEntry entry;
entry.Address = ip + ":" + std::to_string(port);
entry.Name = name;
entry.Description = description;
entry.Version = version;
entry.RequiresPassword = requiresPassword;
entry.Players = players;
entry.MaxPlayers = maxPlayers;
return entry;
}
void ServerList::Sort()
{
_serverEntries.erase(
std::unique(
_serverEntries.begin(), _serverEntries.end(),
[](const ServerListEntry& a, const ServerListEntry& b) {
if (a.Favourite == b.Favourite)
{
return String::iequals(a.Address, b.Address);
}
return false;
}),
_serverEntries.end());
std::sort(_serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& a, const ServerListEntry& b) {
return a.CompareTo(b) < 0;
});
}
ServerListEntry& ServerList::GetServer(size_t index)
{
return _serverEntries[index];
}
size_t ServerList::GetCount() const
{
return _serverEntries.size();
}
void ServerList::Add(const ServerListEntry& entry)
{
_serverEntries.push_back(entry);
Sort();
}
void ServerList::AddRange(const std::vector<ServerListEntry>& entries)
{
_serverEntries.insert(_serverEntries.end(), entries.begin(), entries.end());
Sort();
}
void ServerList::AddOrUpdateRange(const std::vector<ServerListEntry>& entries)
{
for (auto& existsEntry : _serverEntries)
{
auto match = std::find_if(entries.begin(), entries.end(), [&](const ServerListEntry& entry) {
return existsEntry.Address == entry.Address;
});
if (match != entries.end())
{
ServerListEntry serverInfo;
serverInfo.Address = fs.ReadString();
serverInfo.Name = fs.ReadString();
serverInfo.RequiresPassword = false;
serverInfo.Description = fs.ReadString();
serverInfo.Version.clear();
serverInfo.Favourite = true;
serverInfo.Players = 0;
serverInfo.MaxPlayers = 0;
entries.push_back(std::move(serverInfo));
// Keep favourites
auto fav = existsEntry.Favourite;
existsEntry = *match;
existsEntry.Favourite = fav;
}
}
std::vector<ServerListEntry> newServers;
std::copy_if(entries.begin(), entries.end(), std::back_inserter(newServers), [this](const ServerListEntry& entry) {
return std::find_if(
_serverEntries.begin(), _serverEntries.end(),
[&](const ServerListEntry& existsEntry) { return existsEntry.Address == entry.Address; })
== _serverEntries.end();
});
AddRange(newServers);
}
catch (const std::exception& e)
void ServerList::Clear() noexcept
{
LOG_ERROR("Unable to read server list: %s", e.what());
entries = std::vector<ServerListEntry>();
_serverEntries.clear();
}
return entries;
}
void ServerList::ReadAndAddFavourites()
{
_serverEntries.erase(
std::remove_if(
_serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& entry) { return entry.Favourite; }),
_serverEntries.end());
auto entries = ReadFavourites();
AddRange(entries);
}
void ServerList::WriteFavourites() const
{
// Save just favourite servers
std::vector<ServerListEntry> favouriteServers;
std::copy_if(
_serverEntries.begin(), _serverEntries.end(), std::back_inserter(favouriteServers),
[](const ServerListEntry& entry) { return entry.Favourite; });
WriteFavourites(favouriteServers);
}
bool ServerList::WriteFavourites(const std::vector<ServerListEntry>& entries) const
{
LOG_VERBOSE("server_list_write(%d, 0x%p)", entries.size(), entries.data());
auto& env = GetContext()->GetPlatformEnvironment();
auto path = Path::Combine(env.GetDirectoryPath(DirBase::user), u8"servers.cfg");
try
std::vector<ServerListEntry> ServerList::ReadFavourites() const
{
auto fs = FileStream(path, FileMode::write);
fs.WriteValue<uint32_t>(static_cast<uint32_t>(entries.size()));
for (const auto& entry : entries)
{
fs.WriteString(entry.Address);
fs.WriteString(entry.Name);
fs.WriteString(entry.Description);
}
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("Unable to write server list: %s", e.what());
return false;
}
}
std::future<std::vector<ServerListEntry>> ServerList::FetchLocalServerListAsync(const INetworkEndpoint& broadcastEndpoint) const
{
auto broadcastAddress = broadcastEndpoint.GetHostname();
return std::async(std::launch::async, [broadcastAddress] {
constexpr auto kReceiveDelayInMs = 10;
constexpr auto kReceiveWaitInMs = 2000;
std::string_view msg = kNetworkLanBroadcastMsg;
auto udpSocket = CreateUdpSocket();
LOG_VERBOSE("Broadcasting %zu bytes to the LAN (%s)", msg.size(), broadcastAddress.c_str());
auto len = udpSocket->SendData(broadcastAddress, kNetworkLanBroadcastPort, msg.data(), msg.size());
if (len != msg.size())
{
throw std::runtime_error("Unable to broadcast server query.");
}
LOG_VERBOSE("server_list_read(...)");
std::vector<ServerListEntry> entries;
for (int i = 0; i < (kReceiveWaitInMs / kReceiveDelayInMs); i++)
try
{
try
auto& env = GetContext()->GetPlatformEnvironment();
auto path = env.GetFilePath(PathId::networkServers);
if (File::Exists(path))
{
// Start with initialised buffer in case we receive a non-terminated string
char buffer[1024]{};
size_t recievedLen{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint);
if (p == NetworkReadPacket::Success)
auto fs = FileStream(path, FileMode::open);
auto numEntries = fs.ReadValue<uint32_t>();
for (size_t i = 0; i < numEntries; i++)
{
auto sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes back from %s", recievedLen, sender.c_str());
auto jinfo = Json::FromString(std::string_view(buffer));
ServerListEntry serverInfo;
serverInfo.Address = fs.ReadString();
serverInfo.Name = fs.ReadString();
serverInfo.RequiresPassword = false;
serverInfo.Description = fs.ReadString();
serverInfo.Version.clear();
serverInfo.Favourite = true;
serverInfo.Players = 0;
serverInfo.MaxPlayers = 0;
entries.push_back(std::move(serverInfo));
}
}
}
catch (const std::exception& e)
{
LOG_ERROR("Unable to read server list: %s", e.what());
entries = std::vector<ServerListEntry>();
}
return entries;
}
if (jinfo.is_object())
void ServerList::ReadAndAddFavourites()
{
_serverEntries.erase(
std::remove_if(
_serverEntries.begin(), _serverEntries.end(), [](const ServerListEntry& entry) { return entry.Favourite; }),
_serverEntries.end());
auto entries = ReadFavourites();
AddRange(entries);
}
void ServerList::WriteFavourites() const
{
// Save just favourite servers
std::vector<ServerListEntry> favouriteServers;
std::copy_if(
_serverEntries.begin(), _serverEntries.end(), std::back_inserter(favouriteServers),
[](const ServerListEntry& entry) { return entry.Favourite; });
WriteFavourites(favouriteServers);
}
bool ServerList::WriteFavourites(const std::vector<ServerListEntry>& entries) const
{
LOG_VERBOSE("server_list_write(%d, 0x%p)", entries.size(), entries.data());
auto& env = GetContext()->GetPlatformEnvironment();
auto path = Path::Combine(env.GetDirectoryPath(DirBase::user), u8"servers.cfg");
try
{
auto fs = FileStream(path, FileMode::write);
fs.WriteValue<uint32_t>(static_cast<uint32_t>(entries.size()));
for (const auto& entry : entries)
{
fs.WriteString(entry.Address);
fs.WriteString(entry.Name);
fs.WriteString(entry.Description);
}
return true;
}
catch (const std::exception& e)
{
LOG_ERROR("Unable to write server list: %s", e.what());
return false;
}
}
std::future<std::vector<ServerListEntry>> ServerList::FetchLocalServerListAsync(
const INetworkEndpoint& broadcastEndpoint) const
{
auto broadcastAddress = broadcastEndpoint.GetHostname();
return std::async(std::launch::async, [broadcastAddress] {
constexpr auto kReceiveDelayInMs = 10;
constexpr auto kReceiveWaitInMs = 2000;
std::string_view msg = kNetworkLanBroadcastMsg;
auto udpSocket = CreateUdpSocket();
LOG_VERBOSE("Broadcasting %zu bytes to the LAN (%s)", msg.size(), broadcastAddress.c_str());
auto len = udpSocket->SendData(broadcastAddress, kNetworkLanBroadcastPort, msg.data(), msg.size());
if (len != msg.size())
{
throw std::runtime_error("Unable to broadcast server query.");
}
std::vector<ServerListEntry> entries;
for (int i = 0; i < (kReceiveWaitInMs / kReceiveDelayInMs); i++)
{
try
{
// Start with initialised buffer in case we receive a non-terminated string
char buffer[1024]{};
size_t recievedLen{};
std::unique_ptr<INetworkEndpoint> endpoint;
auto p = udpSocket->ReceiveData(buffer, sizeof(buffer) - 1, &recievedLen, &endpoint);
if (p == NetworkReadPacket::Success)
{
jinfo["ip"] = { { "v4", { sender } } };
auto sender = endpoint->GetHostname();
LOG_VERBOSE("Received %zu bytes back from %s", recievedLen, sender.c_str());
auto jinfo = Json::FromString(std::string_view(buffer));
auto entry = ServerListEntry::FromJson(jinfo);
if (entry.has_value())
if (jinfo.is_object())
{
(*entry).Local = true;
entries.push_back(std::move(*entry));
jinfo["ip"] = { { "v4", { sender } } };
auto entry = ServerListEntry::FromJson(jinfo);
if (entry.has_value())
{
(*entry).Local = true;
entries.push_back(std::move(*entry));
}
}
}
}
catch (const std::exception& e)
{
LOG_WARNING("Error receiving data: %s", e.what());
}
Platform::Sleep(kReceiveDelayInMs);
}
catch (const std::exception& e)
return entries;
});
}
std::future<std::vector<ServerListEntry>> ServerList::FetchLocalServerListAsync() const
{
return std::async(std::launch::async, [&] {
// Get all possible LAN broadcast addresses
auto broadcastEndpoints = GetBroadcastAddresses();
// Spin off a fetch for each broadcast address
std::vector<std::future<std::vector<ServerListEntry>>> futures;
for (const auto& broadcastEndpoint : broadcastEndpoints)
{
LOG_WARNING("Error receiving data: %s", e.what());
auto f = FetchLocalServerListAsync(*broadcastEndpoint);
futures.push_back(std::move(f));
}
Platform::Sleep(kReceiveDelayInMs);
}
return entries;
});
}
std::future<std::vector<ServerListEntry>> ServerList::FetchLocalServerListAsync() const
{
return std::async(std::launch::async, [&] {
// Get all possible LAN broadcast addresses
auto broadcastEndpoints = GetBroadcastAddresses();
// Wait and merge all results
std::vector<ServerListEntry> mergedEntries;
for (auto& f : futures)
{
try
{
auto entries = f.get();
mergedEntries.insert(mergedEntries.begin(), entries.begin(), entries.end());
}
catch (...)
{
// Ignore any exceptions from a particular broadcast fetch
}
}
return mergedEntries;
});
}
// Spin off a fetch for each broadcast address
std::vector<std::future<std::vector<ServerListEntry>>> futures;
for (const auto& broadcastEndpoint : broadcastEndpoints)
std::future<std::vector<ServerListEntry>> ServerList::FetchOnlineServerListAsync() const
{
#ifdef DISABLE_HTTP
return {};
#else
auto p = std::make_shared<std::promise<std::vector<ServerListEntry>>>();
auto f = p->get_future();
std::string masterServerUrl = kMasterServerURL;
if (!Config::Get().network.MasterServerUrl.empty())
{
auto f = FetchLocalServerListAsync(*broadcastEndpoint);
futures.push_back(std::move(f));
masterServerUrl = Config::Get().network.MasterServerUrl;
}
// Wait and merge all results
std::vector<ServerListEntry> mergedEntries;
for (auto& f : futures)
{
Http::Request request;
request.url = std::move(masterServerUrl);
request.method = Http::Method::GET;
request.header["Accept"] = "application/json";
Http::DoAsync(request, [p](Http::Response& response) -> void {
json_t root;
try
{
auto entries = f.get();
mergedEntries.insert(mergedEntries.begin(), entries.begin(), entries.end());
if (response.status != Http::Status::Ok)
{
throw MasterServerException(STR_SERVER_LIST_NO_CONNECTION);
}
root = Json::FromString(response.body);
if (root.is_object())
{
auto jsonStatus = root["status"];
if (!jsonStatus.is_number_integer())
{
throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_NUMBER);
}
auto status = Json::GetNumber<int32_t>(jsonStatus);
if (status != 200)
{
throw MasterServerException(STR_SERVER_LIST_MASTER_SERVER_FAILED);
}
auto jServers = root["servers"];
if (!jServers.is_array())
{
throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_ARRAY);
}
std::vector<ServerListEntry> entries;
for (auto& jServer : jServers)
{
if (jServer.is_object())
{
auto entry = ServerListEntry::FromJson(jServer);
if (entry.has_value())
{
entries.push_back(std::move(*entry));
}
}
}
p->set_value(entries);
}
}
catch (...)
{
// Ignore any exceptions from a particular broadcast fetch
p->set_exception(std::current_exception());
}
}
return mergedEntries;
});
}
std::future<std::vector<ServerListEntry>> ServerList::FetchOnlineServerListAsync() const
{
#ifdef DISABLE_HTTP
return {};
#else
auto p = std::make_shared<std::promise<std::vector<ServerListEntry>>>();
auto f = p->get_future();
std::string masterServerUrl = kMasterServerURL;
if (!Config::Get().network.MasterServerUrl.empty())
{
masterServerUrl = Config::Get().network.MasterServerUrl;
});
return f;
#endif
}
Http::Request request;
request.url = std::move(masterServerUrl);
request.method = Http::Method::GET;
request.header["Accept"] = "application/json";
Http::DoAsync(request, [p](Http::Response& response) -> void {
json_t root;
try
{
if (response.status != Http::Status::Ok)
{
throw MasterServerException(STR_SERVER_LIST_NO_CONNECTION);
}
uint32_t ServerList::GetTotalPlayerCount() const
{
return std::accumulate(_serverEntries.begin(), _serverEntries.end(), 0, [](uint32_t acc, const ServerListEntry& entry) {
return acc + entry.Players;
});
}
root = Json::FromString(response.body);
if (root.is_object())
{
auto jsonStatus = root["status"];
if (!jsonStatus.is_number_integer())
{
throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_NUMBER);
}
auto status = Json::GetNumber<int32_t>(jsonStatus);
if (status != 200)
{
throw MasterServerException(STR_SERVER_LIST_MASTER_SERVER_FAILED);
}
auto jServers = root["servers"];
if (!jServers.is_array())
{
throw MasterServerException(STR_SERVER_LIST_INVALID_RESPONSE_JSON_ARRAY);
}
std::vector<ServerListEntry> entries;
for (auto& jServer : jServers)
{
if (jServer.is_object())
{
auto entry = ServerListEntry::FromJson(jServer);
if (entry.has_value())
{
entries.push_back(std::move(*entry));
}
}
}
p->set_value(entries);
}
}
catch (...)
{
p->set_exception(std::current_exception());
}
});
return f;
#endif
}
uint32_t ServerList::GetTotalPlayerCount() const
{
return std::accumulate(_serverEntries.begin(), _serverEntries.end(), 0, [](uint32_t acc, const ServerListEntry& entry) {
return acc + entry.Players;
});
}
const char* MasterServerException::what() const noexcept
{
static std::string localisedStatusText = LanguageGetString(StatusText);
return localisedStatusText.c_str();
}
const char* MasterServerException::what() const noexcept
{
static std::string localisedStatusText = LanguageGetString(StatusText);
return localisedStatusText.c_str();
}
} // namespace OpenRCT2::Network
#endif

125
src/openrct2/network/ServerList.h
View File

@@ -18,68 +18,71 @@
#include <string>
#include <vector>
struct INetworkEndpoint;
struct ServerListEntry
namespace OpenRCT2::Network
{
std::string Address;
std::string Name;
std::string Description;
std::string Version;
bool RequiresPassword{};
bool Favourite{};
uint8_t Players{};
uint8_t MaxPlayers{};
bool Local{};
struct INetworkEndpoint;
int32_t CompareTo(const ServerListEntry& other) const;
bool IsVersionValid() const noexcept;
/**
* Creates a ServerListEntry object from a JSON object
*
* @param json JSON data source - must be object type
* @return A NetworkGroup object
* @note json is deliberately left non-const: json_t behaviour changes when const
*/
static std::optional<ServerListEntry> FromJson(json_t& server);
};
class ServerList
{
private:
std::vector<ServerListEntry> _serverEntries;
void Sort();
std::vector<ServerListEntry> ReadFavourites() const;
bool WriteFavourites(const std::vector<ServerListEntry>& entries) const;
std::future<std::vector<ServerListEntry>> FetchLocalServerListAsync(const INetworkEndpoint& broadcastEndpoint) const;
public:
ServerListEntry& GetServer(size_t index);
size_t GetCount() const;
void Add(const ServerListEntry& entry);
void AddRange(const std::vector<ServerListEntry>& entries);
void AddOrUpdateRange(const std::vector<ServerListEntry>& entries);
void Clear() noexcept;
void ReadAndAddFavourites();
void WriteFavourites() const;
std::future<std::vector<ServerListEntry>> FetchLocalServerListAsync() const;
std::future<std::vector<ServerListEntry>> FetchOnlineServerListAsync() const;
uint32_t GetTotalPlayerCount() const;
};
class MasterServerException : public std::exception
{
public:
StringId StatusText;
MasterServerException(StringId statusText)
: StatusText(statusText)
struct ServerListEntry
{
}
std::string Address;
std::string Name;
std::string Description;
std::string Version;
bool RequiresPassword{};
bool Favourite{};
uint8_t Players{};
uint8_t MaxPlayers{};
bool Local{};
const char* what() const noexcept override;
};
int32_t CompareTo(const ServerListEntry& other) const;
bool IsVersionValid() const noexcept;
/**
* Creates a ServerListEntry object from a JSON object
*
* @param json JSON data source - must be object type
* @return A NetworkGroup object
* @note json is deliberately left non-const: json_t behaviour changes when const
*/
static std::optional<ServerListEntry> FromJson(json_t& server);
};
class ServerList
{
private:
std::vector<ServerListEntry> _serverEntries;
void Sort();
std::vector<ServerListEntry> ReadFavourites() const;
bool WriteFavourites(const std::vector<ServerListEntry>& entries) const;
std::future<std::vector<ServerListEntry>> FetchLocalServerListAsync(const INetworkEndpoint& broadcastEndpoint) const;
public:
ServerListEntry& GetServer(size_t index);
size_t GetCount() const;
void Add(const ServerListEntry& entry);
void AddRange(const std::vector<ServerListEntry>& entries);
void AddOrUpdateRange(const std::vector<ServerListEntry>& entries);
void Clear() noexcept;
void ReadAndAddFavourites();
void WriteFavourites() const;
std::future<std::vector<ServerListEntry>> FetchLocalServerListAsync() const;
std::future<std::vector<ServerListEntry>> FetchOnlineServerListAsync() const;
uint32_t GetTotalPlayerCount() const;
};
class MasterServerException : public std::exception
{
public:
StringId StatusText;
MasterServerException(StringId statusText)
: StatusText(statusText)
{
}
const char* what() const noexcept override;
};
} // namespace OpenRCT2::Network

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

File diff suppressed because it is too large Load Diff

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

@@ -13,93 +13,96 @@
#include <string>
#include <vector>
enum class SocketStatus
namespace OpenRCT2::Network
{
Closed,
Waiting,
Resolving,
Connecting,
Connected,
Listening,
};
enum class NetworkReadPacket : int32_t
{
Success,
NoData,
MoreData,
Disconnected
};
/**
* Represents an address and port.
*/
struct INetworkEndpoint
{
virtual ~INetworkEndpoint()
enum class SocketStatus
{
}
Closed,
Waiting,
Resolving,
Connecting,
Connected,
Listening,
};
virtual std::string GetHostname() const = 0;
};
enum class NetworkReadPacket : int32_t
{
Success,
NoData,
MoreData,
Disconnected
};
/**
* Represents a TCP socket / connection or listener.
*/
struct ITcpSocket
{
public:
virtual ~ITcpSocket() = default;
/**
* Represents an address and port.
*/
struct INetworkEndpoint
{
virtual ~INetworkEndpoint()
{
}
virtual SocketStatus GetStatus() const = 0;
virtual const char* GetError() const = 0;
virtual const char* GetHostName() const = 0;
virtual std::string GetIpAddress() const = 0;
virtual std::string GetHostname() const = 0;
};
virtual void Listen(uint16_t port) = 0;
virtual void Listen(const std::string& address, uint16_t port) = 0;
[[nodiscard]] virtual std::unique_ptr<ITcpSocket> Accept() = 0;
/**
* Represents a TCP socket / connection or listener.
*/
struct ITcpSocket
{
public:
virtual ~ITcpSocket() = default;
virtual void Connect(const std::string& address, uint16_t port) = 0;
virtual void ConnectAsync(const std::string& address, uint16_t port) = 0;
virtual SocketStatus GetStatus() const = 0;
virtual const char* GetError() const = 0;
virtual const char* GetHostName() const = 0;
virtual std::string GetIpAddress() const = 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 void Listen(uint16_t port) = 0;
virtual void Listen(const std::string& address, uint16_t port) = 0;
[[nodiscard]] virtual std::unique_ptr<ITcpSocket> Accept() = 0;
virtual void SetNoDelay(bool noDelay) = 0;
virtual void Connect(const std::string& address, uint16_t port) = 0;
virtual void ConnectAsync(const std::string& address, uint16_t port) = 0;
virtual void Finish() = 0;
virtual void Disconnect() = 0;
virtual void Close() = 0;
};
virtual size_t SendData(const void* buffer, size_t size) = 0;
virtual NetworkReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) = 0;
/**
* Represents a UDP socket / listener.
*/
struct IUdpSocket
{
public:
virtual ~IUdpSocket() = default;
virtual void SetNoDelay(bool noDelay) = 0;
virtual SocketStatus GetStatus() const = 0;
virtual const char* GetError() const = 0;
virtual const char* GetHostName() const = 0;
virtual void Finish() = 0;
virtual void Disconnect() = 0;
virtual void Close() = 0;
};
virtual void Listen(uint16_t port) = 0;
virtual void Listen(const std::string& address, uint16_t port) = 0;
/**
* Represents a UDP socket / listener.
*/
struct IUdpSocket
{
public:
virtual ~IUdpSocket() = default;
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(
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender)
= 0;
virtual SocketStatus GetStatus() const = 0;
virtual const char* GetError() const = 0;
virtual const char* GetHostName() const = 0;
virtual void Close() = 0;
};
virtual void Listen(uint16_t port) = 0;
virtual void Listen(const std::string& address, uint16_t port) = 0;
[[nodiscard]] std::unique_ptr<ITcpSocket> CreateTcpSocket();
[[nodiscard]] std::unique_ptr<IUdpSocket> CreateUdpSocket();
[[nodiscard]] std::vector<std::unique_ptr<INetworkEndpoint>> GetBroadcastAddresses();
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(
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender)
= 0;
virtual void Close() = 0;
};
[[nodiscard]] std::unique_ptr<ITcpSocket> CreateTcpSocket();
[[nodiscard]] std::unique_ptr<IUdpSocket> CreateUdpSocket();
[[nodiscard]] std::vector<std::unique_ptr<INetworkEndpoint>> GetBroadcastAddresses();
} // namespace OpenRCT2::Network
namespace OpenRCT2::Convert
{