mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #8751 from ZehMatt/fix-8741 

utf8* string refactor.
This commit is contained in:
ζeh Matt 2019-02-24 17:33:37 +01:00 committed by GitHub
parent 6a0cff2676 a7f8c8aa36
commit 92b6ed5a94
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 108 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/openrct2-ui/windows/ServerList.cpp
View File

@ -181,7 +181,7 @@ rct_window* window_server_list_open()
window_set_resize(window, WWIDTH_MIN, WHEIGHT_MIN, WWIDTH_MAX, WHEIGHT_MAX); window_set_resize(window, WWIDTH_MIN, WHEIGHT_MIN, WWIDTH_MAX, WHEIGHT_MAX);
safe_strcpy(_playerName, gConfigNetwork.player_name, sizeof(_playerName)); safe_strcpy(_playerName, gConfigNetwork.player_name.c_str(), sizeof(_playerName));
server_list_load_server_entries(); server_list_load_server_entries();
window->no_list_items = (uint16_t)_serverEntries.size(); window->no_list_items = (uint16_t)_serverEntries.size();
@ -378,8 +378,7 @@ static void window_server_list_textinput(rct_window* w, rct_widgetindex widgetIn
if (strlen(_playerName) > 0) if (strlen(_playerName) > 0)
{ {
SafeFree(gConfigNetwork.player_name); gConfigNetwork.player_name = _playerName;
gConfigNetwork.player_name = _strdup(_playerName);
config_save_default(); config_save_default();
} }
@ -639,8 +638,8 @@ static void join_server(std::string address)
#ifndef DISABLE_HTTP #ifndef DISABLE_HTTP
static void fetch_servers() static void fetch_servers()
{ {
const char* masterServerUrl = OPENRCT2_MASTER_SERVER_URL; std::string masterServerUrl = OPENRCT2_MASTER_SERVER_URL;
if (!str_is_null_or_empty(gConfigNetwork.master_server_url)) if (gConfigNetwork.master_server_url.empty() == false)
{ {
masterServerUrl = gConfigNetwork.master_server_url; masterServerUrl = gConfigNetwork.master_server_url;
} }

19
src/openrct2-ui/windows/ServerStart.cpp
View File

@ -137,9 +137,9 @@ rct_window* window_server_start_open()
window->list_information_type = 0; window->list_information_type = 0;
snprintf(_port, 7, "%u", gConfigNetwork.default_port); snprintf(_port, 7, "%u", gConfigNetwork.default_port);
safe_strcpy(_name, gConfigNetwork.server_name, sizeof(_name)); safe_strcpy(_name, gConfigNetwork.server_name.c_str(), sizeof(_name));
safe_strcpy(_description, gConfigNetwork.server_description, sizeof(_description)); safe_strcpy(_description, gConfigNetwork.server_description.c_str(), sizeof(_description));
safe_strcpy(_greeting, gConfigNetwork.server_greeting, sizeof(_greeting)); safe_strcpy(_greeting, gConfigNetwork.server_greeting.c_str(), sizeof(_greeting));
return window; return window;
} }
@ -153,7 +153,7 @@ static void window_server_start_scenarioselect_callback(const utf8* path)
network_set_password(_password); network_set_password(_password);
if (context_load_park_from_file(path)) if (context_load_park_from_file(path))
{ {
network_begin_server(gConfigNetwork.default_port, gConfigNetwork.listen_address); network_begin_server(gConfigNetwork.default_port, gConfigNetwork.listen_address.c_str());
} }
} }
@ -161,7 +161,7 @@ static void window_server_start_loadsave_callback(int32_t result, const utf8* pa
{ {
if (result == MODAL_RESULT_OK && context_load_park_from_file(path)) if (result == MODAL_RESULT_OK && context_load_park_from_file(path))
{ {
network_begin_server(gConfigNetwork.default_port, gConfigNetwork.listen_address); network_begin_server(gConfigNetwork.default_port, gConfigNetwork.listen_address.c_str());
} }
} }
@ -267,8 +267,7 @@ static void window_server_start_textinput(rct_window* w, rct_widgetindex widgetI
if (strlen(_name) > 0) if (strlen(_name) > 0)
{ {
SafeFree(gConfigNetwork.server_name); gConfigNetwork.server_name = _name;
gConfigNetwork.server_name = _strdup(_name);
config_save_default(); config_save_default();
} }
@ -286,8 +285,7 @@ static void window_server_start_textinput(rct_window* w, rct_widgetindex widgetI
if (strlen(_description) > 0) if (strlen(_description) > 0)
{ {
SafeFree(gConfigNetwork.server_description); gConfigNetwork.server_description = _description;
gConfigNetwork.server_description = _strdup(_description);
config_save_default(); config_save_default();
} }
@ -305,8 +303,7 @@ static void window_server_start_textinput(rct_window* w, rct_widgetindex widgetI
if (strlen(_greeting) > 0) if (strlen(_greeting) > 0)
{ {
SafeFree(gConfigNetwork.server_greeting); gConfigNetwork.server_greeting = _greeting;
gConfigNetwork.server_greeting = _strdup(_greeting);
config_save_default(); config_save_default();
} }

4
src/openrct2/Context.cpp
View File

@ -739,14 +739,14 @@ namespace OpenRCT2
gNetworkStartPort = gConfigNetwork.default_port; gNetworkStartPort = gConfigNetwork.default_port;
} }
if (String::IsNullOrEmpty(gNetworkStartAddress)) if (gNetworkStartAddress.empty())
{ {
gNetworkStartAddress = gConfigNetwork.listen_address; gNetworkStartAddress = gConfigNetwork.listen_address;
} }
if (String::IsNullOrEmpty(gCustomPassword)) if (String::IsNullOrEmpty(gCustomPassword))
{ {
network_set_password(gConfigNetwork.default_password); network_set_password(gConfigNetwork.default_password.c_str());
} }
else else
{ {

6
src/openrct2/OpenRCT2.h
View File

@ -11,6 +11,8 @@
#include "common.h" #include "common.h"
#include <string>
enum STARTUP_ACTION enum STARTUP_ACTION
{ {
STARTUP_ACTION_NONE, STARTUP_ACTION_NONE,
@ -50,9 +52,9 @@ extern bool gOpenRCT2SilentBreakpad;
#ifndef DISABLE_NETWORK #ifndef DISABLE_NETWORK
extern int32_t gNetworkStart; extern int32_t gNetworkStart;
extern char gNetworkStartHost[128]; extern std::string gNetworkStartHost;
extern int32_t gNetworkStartPort; extern int32_t gNetworkStartPort;
extern char* gNetworkStartAddress; extern std::string gNetworkStartAddress;
#endif #endif
extern uint32_t gCurrentDrawCount; extern uint32_t gCurrentDrawCount;

7
src/openrct2/cmdline/RootCommands.cpp
View File

@ -27,6 +27,7 @@
#include <ctime> #include <ctime>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <string>
#ifdef USE_BREAKPAD #ifdef USE_BREAKPAD
# define IMPLIES_SILENT_BREAKPAD ", implies --silent-breakpad" # define IMPLIES_SILENT_BREAKPAD ", implies --silent-breakpad"
@ -36,9 +37,9 @@
#ifndef DISABLE_NETWORK #ifndef DISABLE_NETWORK
int32_t gNetworkStart = NETWORK_MODE_NONE; int32_t gNetworkStart = NETWORK_MODE_NONE;
char gNetworkStartHost[128]; std::string gNetworkStartHost;
int32_t gNetworkStartPort = NETWORK_DEFAULT_PORT; int32_t gNetworkStartPort = NETWORK_DEFAULT_PORT;
char* gNetworkStartAddress = nullptr; std::string gNetworkStartAddress;
static uint32_t _port = 0; static uint32_t _port = 0;
static char* _address = nullptr; static char* _address = nullptr;
@ -326,7 +327,7 @@ exitcode_t HandleCommandJoin(CommandLineArgEnumerator* enumerator)
gNetworkStart = NETWORK_MODE_CLIENT; gNetworkStart = NETWORK_MODE_CLIENT;
gNetworkStartPort = _port; gNetworkStartPort = _port;
String::Set(gNetworkStartHost, sizeof(gNetworkStartHost), hostname); gNetworkStartHost = hostname;
return EXITCODE_CONTINUE; return EXITCODE_CONTINUE;
} }

2
src/openrct2/cmdline/UriHandler.cpp
View File

@ -64,7 +64,7 @@ static exitcode_t HandleUriJoin(const std::vector<std::string>& args)
{ {
// Set the network start configuration // Set the network start configuration
gNetworkStart = NETWORK_MODE_CLIENT; gNetworkStart = NETWORK_MODE_CLIENT;
String::Set(gNetworkStartHost, sizeof(gNetworkStartHost), hostname.c_str()); gNetworkStartHost = hostname;
gNetworkStartPort = port; gNetworkStartPort = port;
return EXITCODE_CONTINUE; return EXITCODE_CONTINUE;
} }

28
src/openrct2/config/Config.cpp
View File

@ -377,18 +377,18 @@ namespace Config
auto model = &gConfigNetwork; auto model = &gConfigNetwork;
model->player_name = String::Duplicate(playerName); model->player_name = String::Duplicate(playerName);
model->default_port = reader->GetInt32("default_port", NETWORK_DEFAULT_PORT); model->default_port = reader->GetInt32("default_port", NETWORK_DEFAULT_PORT);
model->listen_address = reader->GetCString("listen_address", ""); model->listen_address = reader->GetString("listen_address", "");
model->default_password = reader->GetCString("default_password", nullptr); model->default_password = reader->GetString("default_password", "");
model->stay_connected = reader->GetBoolean("stay_connected", true); model->stay_connected = reader->GetBoolean("stay_connected", true);
model->advertise = reader->GetBoolean("advertise", true); model->advertise = reader->GetBoolean("advertise", true);
model->maxplayers = reader->GetInt32("maxplayers", 16); model->maxplayers = reader->GetInt32("maxplayers", 16);
model->server_name = reader->GetCString("server_name", "Server"); model->server_name = reader->GetString("server_name", "Server");
model->server_description = reader->GetCString("server_description", nullptr); model->server_description = reader->GetString("server_description", "");
model->server_greeting = reader->GetCString("server_greeting", nullptr); model->server_greeting = reader->GetString("server_greeting", "");
model->master_server_url = reader->GetCString("master_server_url", nullptr); model->master_server_url = reader->GetString("master_server_url", "");
model->provider_name = reader->GetCString("provider_name", nullptr); model->provider_name = reader->GetString("provider_name", "");
model->provider_email = reader->GetCString("provider_email", nullptr); model->provider_email = reader->GetString("provider_email", "");
model->provider_website = reader->GetCString("provider_website", nullptr); model->provider_website = reader->GetString("provider_website", "");
model->known_keys_only = reader->GetBoolean("known_keys_only", false); model->known_keys_only = reader->GetBoolean("known_keys_only", false);
model->log_chat = reader->GetBoolean("log_chat", false); model->log_chat = reader->GetBoolean("log_chat", false);
model->log_server_actions = reader->GetBoolean("log_server_actions", false); model->log_server_actions = reader->GetBoolean("log_server_actions", false);
@ -753,16 +753,6 @@ void config_release()
SafeFree(gConfigSound.device); SafeFree(gConfigSound.device);
SafeFree(gConfigTwitch.api_url); SafeFree(gConfigTwitch.api_url);
SafeFree(gConfigTwitch.channel); SafeFree(gConfigTwitch.channel);
SafeFree(gConfigNetwork.player_name);
SafeFree(gConfigNetwork.listen_address);
SafeFree(gConfigNetwork.default_password);
SafeFree(gConfigNetwork.server_name);
SafeFree(gConfigNetwork.server_description);
SafeFree(gConfigNetwork.server_greeting);
SafeFree(gConfigNetwork.master_server_url);
SafeFree(gConfigNetwork.provider_name);
SafeFree(gConfigNetwork.provider_email);
SafeFree(gConfigNetwork.provider_website);
SafeFree(gConfigFonts.file_name); SafeFree(gConfigFonts.file_name);
SafeFree(gConfigFonts.font_name); SafeFree(gConfigFonts.font_name);
} }

22
src/openrct2/config/Config.h
View File

@ -11,6 +11,8 @@
#include "../common.h" #include "../common.h"
#include <string>
struct GeneralConfiguration struct GeneralConfiguration
{ {
// Paths // Paths
@ -135,20 +137,20 @@ struct TwitchConfiguration
struct NetworkConfiguration struct NetworkConfiguration
{ {
utf8* player_name; std::string player_name;
int32_t default_port; int32_t default_port;
char* listen_address; std::string listen_address;
utf8* default_password; std::string default_password;
bool stay_connected; bool stay_connected;
bool advertise; bool advertise;
int32_t maxplayers; int32_t maxplayers;
utf8* server_name; std::string server_name;
utf8* server_description; std::string server_description;
utf8* server_greeting; std::string server_greeting;
utf8* master_server_url; std::string master_server_url;
utf8* provider_name; std::string provider_name;
utf8* provider_email; std::string provider_email;
utf8* provider_website; std::string provider_website;
bool known_keys_only; bool known_keys_only;
bool log_chat; bool log_chat;
bool log_server_actions; bool log_server_actions;

94
src/openrct2/network/Network.cpp
View File

@ -102,8 +102,8 @@ enum
static void network_chat_show_connected_message(); static void network_chat_show_connected_message();
static void network_chat_show_server_greeting(); static void network_chat_show_server_greeting();
static void network_get_keys_directory(utf8* buffer, size_t bufferSize); static void network_get_keys_directory(utf8* buffer, size_t bufferSize);
static void network_get_private_key_path(utf8* buffer, size_t bufferSize, const utf8* playerName); static void network_get_private_key_path(utf8* buffer, size_t bufferSize, const std::string& playerName);
static void network_get_public_key_path(utf8* buffer, size_t bufferSize, const utf8* playerName, const utf8* hash); static void network_get_public_key_path(utf8* buffer, size_t bufferSize, const std::string& playerName, const utf8* hash);
class Network class Network
{ {
@ -113,8 +113,8 @@ public:
void SetEnvironment(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env); void SetEnvironment(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env);
bool Init(); bool Init();
void Close(); void Close();
bool BeginClient(const char* host, uint16_t port); bool BeginClient(const std::string& host, uint16_t port);
bool BeginServer(uint16_t port, const char* address); bool BeginServer(uint16_t port, const std::string& address);
int32_t GetMode(); int32_t GetMode();
int32_t GetStatus(); int32_t GetStatus();
int32_t GetAuthStatus(); int32_t GetAuthStatus();
@ -157,7 +157,9 @@ public:
void CloseServerLog(); void CloseServerLog();
void Client_Send_TOKEN(); void Client_Send_TOKEN();
void Client_Send_AUTH(const char* name, const char* password, const char* pubkey, const char* sig, size_t sigsize); void Client_Send_AUTH(
const std::string& name, const std::string& password, const std::string& pubkey, const std::string& sig,
size_t sigsize);
void Server_Send_AUTH(NetworkConnection& connection); void Server_Send_AUTH(NetworkConnection& connection);
void Server_Send_TOKEN(NetworkConnection& connection); void Server_Send_TOKEN(NetworkConnection& connection);
void Server_Send_MAP(NetworkConnection* connection = nullptr); void Server_Send_MAP(NetworkConnection* connection = nullptr);
@ -209,10 +211,10 @@ private:
void AddClient(std::unique_ptr<ITcpSocket>&& socket); void AddClient(std::unique_ptr<ITcpSocket>&& socket);
void RemoveClient(std::unique_ptr<NetworkConnection>& connection); void RemoveClient(std::unique_ptr<NetworkConnection>& connection);
NetworkPlayer* AddPlayer(const utf8* name, const std::string& keyhash); NetworkPlayer* AddPlayer(const std::string& name, const std::string& keyhash);
std::string MakePlayerNameUnique(const std::string& name); std::string MakePlayerNameUnique(const std::string& name);
const char* GetMasterServerUrl(); std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey(); std::string GenerateAdvertiseKey();
void SetupDefaultGroups(); void SetupDefaultGroups();
@ -465,7 +467,7 @@ void Network::CloseConnection()
DisposeWSA(); DisposeWSA();
} }
bool Network::BeginClient(const char* host, uint16_t port) bool Network::BeginClient(const std::string& host, uint16_t port)
{ {
if (GetMode() != NETWORK_MODE_NONE) if (GetMode() != NETWORK_MODE_NONE)
{ {
@ -478,7 +480,7 @@ bool Network::BeginClient(const char* host, uint16_t port)
mode = NETWORK_MODE_CLIENT; mode = NETWORK_MODE_CLIENT;
log_info("Connecting to %s:%u\n", host, port); log_info("Connecting to %s:%u\n", host.c_str(), port);
_serverConnection = std::make_unique<NetworkConnection>(); _serverConnection = std::make_unique<NetworkConnection>();
_serverConnection->Socket = CreateTcpSocket(); _serverConnection->Socket = CreateTcpSocket();
@ -557,7 +559,7 @@ bool Network::BeginClient(const char* host, uint16_t port)
return true; return true;
} }
bool Network::BeginServer(uint16_t port, const char* address) bool Network::BeginServer(uint16_t port, const std::string& address)
{ {
Close(); Close();
if (!Init()) if (!Init())
@ -567,9 +569,6 @@ bool Network::BeginServer(uint16_t port, const char* address)
_userManager.Load(); _userManager.Load();
if (strlen(address) == 0)
address = nullptr;
log_verbose("Begin listening for clients"); log_verbose("Begin listening for clients");
_listenSocket = CreateTcpSocket(); _listenSocket = CreateTcpSocket();
@ -584,12 +583,12 @@ bool Network::BeginServer(uint16_t port, const char* address)
return false; return false;
} }
ServerName = String::ToStd(gConfigNetwork.server_name); ServerName = gConfigNetwork.server_name;
ServerDescription = String::ToStd(gConfigNetwork.server_description); ServerDescription = gConfigNetwork.server_description;
ServerGreeting = String::ToStd(gConfigNetwork.server_greeting); ServerGreeting = gConfigNetwork.server_greeting;
ServerProviderName = String::ToStd(gConfigNetwork.provider_name); ServerProviderName = gConfigNetwork.provider_name;
ServerProviderEmail = String::ToStd(gConfigNetwork.provider_email); ServerProviderEmail = gConfigNetwork.provider_email;
ServerProviderWebsite = String::ToStd(gConfigNetwork.provider_website); ServerProviderWebsite = gConfigNetwork.provider_website;
cheats_reset(); cheats_reset();
LoadGroups(); LoadGroups();
@ -1028,9 +1027,9 @@ std::string Network::GenerateAdvertiseKey()
return key; return key;
} }
const char* Network::GetMasterServerUrl() std::string Network::GetMasterServerUrl()
{ {
if (str_is_null_or_empty(gConfigNetwork.master_server_url)) if (gConfigNetwork.master_server_url.empty())
{ {
return OPENRCT2_MASTER_SERVER_URL; return OPENRCT2_MASTER_SERVER_URL;
} }
@ -1351,17 +1350,18 @@ void Network::Client_Send_TOKEN()
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
void Network::Client_Send_AUTH(const char* name, const char* password, const char* pubkey, const char* sig, size_t sigsize) void Network::Client_Send_AUTH(
const std::string& name, const std::string& password, const std::string& pubkey, const std::string& sig, size_t sigsize)
{ {
std::unique_ptr<NetworkPacket> packet(NetworkPacket::Allocate()); std::unique_ptr<NetworkPacket> packet(NetworkPacket::Allocate());
*packet << (uint32_t)NETWORK_COMMAND_AUTH; *packet << (uint32_t)NETWORK_COMMAND_AUTH;
packet->WriteString(network_get_version().c_str()); packet->WriteString(network_get_version().c_str());
packet->WriteString(name); packet->WriteString(name.c_str());
packet->WriteString(password); packet->WriteString(password.c_str());
packet->WriteString(pubkey); packet->WriteString(pubkey.c_str());
assert(sigsize <= (size_t)UINT32_MAX); assert(sigsize <= (size_t)UINT32_MAX);
*packet << (uint32_t)sigsize; *packet << (uint32_t)sigsize;
packet->Write((const uint8_t*)sig, sigsize); packet->Write((const uint8_t*)sig.c_str(), sigsize);
_serverConnection->AuthStatus = NETWORK_AUTH_REQUESTED; _serverConnection->AuthStatus = NETWORK_AUTH_REQUESTED;
_serverConnection->QueuePacket(std::move(packet)); _serverConnection->QueuePacket(std::move(packet));
} }
@ -1700,20 +1700,20 @@ void Network::Server_Send_GAMEINFO(NetworkConnection& connection)
*packet << (uint32_t)NETWORK_COMMAND_GAMEINFO; *packet << (uint32_t)NETWORK_COMMAND_GAMEINFO;
# ifndef DISABLE_HTTP # ifndef DISABLE_HTTP
json_t* obj = json_object(); json_t* obj = json_object();
json_object_set_new(obj, "name", json_string(gConfigNetwork.server_name)); json_object_set_new(obj, "name", json_string(gConfigNetwork.server_name.c_str()));
json_object_set_new(obj, "requiresPassword", json_boolean(_password.size() > 0)); json_object_set_new(obj, "requiresPassword", json_boolean(_password.size() > 0));
json_object_set_new(obj, "version", json_string(network_get_version().c_str())); json_object_set_new(obj, "version", json_string(network_get_version().c_str()));
json_object_set_new(obj, "players", json_integer(player_list.size())); json_object_set_new(obj, "players", json_integer(player_list.size()));
json_object_set_new(obj, "maxPlayers", json_integer(gConfigNetwork.maxplayers)); json_object_set_new(obj, "maxPlayers", json_integer(gConfigNetwork.maxplayers));
json_object_set_new(obj, "description", json_string(gConfigNetwork.server_description)); json_object_set_new(obj, "description", json_string(gConfigNetwork.server_description.c_str()));
json_object_set_new(obj, "greeting", json_string(gConfigNetwork.server_greeting)); json_object_set_new(obj, "greeting", json_string(gConfigNetwork.server_greeting.c_str()));
json_object_set_new(obj, "dedicated", json_boolean(gOpenRCT2Headless)); json_object_set_new(obj, "dedicated", json_boolean(gOpenRCT2Headless));
// Provider details // Provider details
json_t* jsonProvider = json_object(); json_t* jsonProvider = json_object();
json_object_set_new(jsonProvider, "name", json_string(gConfigNetwork.provider_name)); json_object_set_new(jsonProvider, "name", json_string(gConfigNetwork.provider_name.c_str()));
json_object_set_new(jsonProvider, "email", json_string(gConfigNetwork.provider_email)); json_object_set_new(jsonProvider, "email", json_string(gConfigNetwork.provider_email.c_str()));
json_object_set_new(jsonProvider, "website", json_string(gConfigNetwork.provider_website)); json_object_set_new(jsonProvider, "website", json_string(gConfigNetwork.provider_website.c_str()));
json_object_set_new(obj, "provider", jsonProvider); json_object_set_new(obj, "provider", jsonProvider);
packet->WriteString(json_dumps(obj, 0)); packet->WriteString(json_dumps(obj, 0));
@ -2053,7 +2053,7 @@ void Network::RemoveClient(std::unique_ptr<NetworkConnection>& connection)
Server_Send_PLAYERLIST(); Server_Send_PLAYERLIST();
} }
NetworkPlayer* Network::AddPlayer(const utf8* name, const std::string& keyhash) NetworkPlayer* Network::AddPlayer(const std::string& name, const std::string& keyhash)
{ {
NetworkPlayer* addedplayer = nullptr; NetworkPlayer* addedplayer = nullptr;
int32_t newid = -1; int32_t newid = -1;
@ -2093,9 +2093,9 @@ NetworkPlayer* Network::AddPlayer(const utf8* name, const std::string& keyhash)
if (networkUser == nullptr) if (networkUser == nullptr)
{ {
player->Group = GetDefaultGroup(); player->Group = GetDefaultGroup();
if (!String::IsNullOrEmpty(name)) if (name.empty() == false)
{ {
player->SetName(MakePlayerNameUnique(String::Trim(std::string(name)))); player->SetName(MakePlayerNameUnique(String::Trim(name)));
} }
} }
else else
@ -2205,7 +2205,7 @@ void Network::Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket&
_key.Unload(); _key.Unload();
const char* password = String::IsNullOrEmpty(gCustomPassword) ? "" : gCustomPassword; const char* password = String::IsNullOrEmpty(gCustomPassword) ? "" : gCustomPassword;
Client_Send_AUTH(gConfigNetwork.player_name, password, pubkey.c_str(), signature, sigsize); Client_Send_AUTH(gConfigNetwork.player_name.c_str(), password, pubkey.c_str(), signature, sigsize);
delete[] signature; delete[] signature;
} }
@ -3082,12 +3082,12 @@ void network_shutdown_client()
gNetwork.ShutdownClient(); gNetwork.ShutdownClient();
} }
int32_t network_begin_client(const char* host, int32_t port) int32_t network_begin_client(const std::string& host, int32_t port)
{ {
return gNetwork.BeginClient(host, port); return gNetwork.BeginClient(host, port);
} }
int32_t network_begin_server(int32_t port, const char* address) int32_t network_begin_server(int32_t port, const std::string& address)
{ {
return gNetwork.BeginServer(port, address); return gNetwork.BeginServer(port, address);
} }
@ -3788,7 +3788,7 @@ void network_send_gamecmd(
} }
} }
void network_send_password(const char* password) void network_send_password(const std::string& password)
{ {
utf8 keyPath[MAX_PATH]; utf8 keyPath[MAX_PATH];
network_get_private_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name); network_get_private_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name);
@ -3814,7 +3814,7 @@ void network_send_password(const char* password)
// Don't keep private key in memory. There's no need and it may get leaked // Don't keep private key in memory. There's no need and it may get leaked
// when process dump gets collected at some point in future. // when process dump gets collected at some point in future.
gNetwork._key.Unload(); gNetwork._key.Unload();
gNetwork.Client_Send_AUTH(gConfigNetwork.player_name, password, pubkey.c_str(), signature, sigsize); gNetwork.Client_Send_AUTH(gConfigNetwork.player_name.c_str(), password, pubkey.c_str(), signature, sigsize);
delete[] signature; delete[] signature;
} }
@ -3838,17 +3838,17 @@ static void network_get_keys_directory(utf8* buffer, size_t bufferSize)
platform_get_user_directory(buffer, "keys", bufferSize); platform_get_user_directory(buffer, "keys", bufferSize);
} }
static void network_get_private_key_path(utf8* buffer, size_t bufferSize, const utf8* playerName) static void network_get_private_key_path(utf8* buffer, size_t bufferSize, const std::string& playerName)
{ {
network_get_keys_directory(buffer, bufferSize); network_get_keys_directory(buffer, bufferSize);
Path::Append(buffer, bufferSize, playerName); Path::Append(buffer, bufferSize, playerName.c_str());
String::Append(buffer, bufferSize, ".privkey"); String::Append(buffer, bufferSize, ".privkey");
} }
static void network_get_public_key_path(utf8* buffer, size_t bufferSize, const utf8* playerName, const utf8* hash) static void network_get_public_key_path(utf8* buffer, size_t bufferSize, const std::string& playerName, const utf8* hash)
{ {
network_get_keys_directory(buffer, bufferSize); network_get_keys_directory(buffer, bufferSize);
Path::Append(buffer, bufferSize, playerName); Path::Append(buffer, bufferSize, playerName.c_str());
String::Append(buffer, bufferSize, "-"); String::Append(buffer, bufferSize, "-");
String::Append(buffer, bufferSize, hash); String::Append(buffer, bufferSize, hash);
String::Append(buffer, bufferSize, ".pubkey"); String::Append(buffer, bufferSize, ".pubkey");
@ -3934,11 +3934,11 @@ void network_update()
void network_process_pending() void network_process_pending()
{ {
} }
int32_t network_begin_client(const char* host, int32_t port) int32_t network_begin_client(const std::string& host, int32_t port)
{ {
return 1; return 1;
} }
int32_t network_begin_server(int32_t port, const char* address) int32_t network_begin_server(int32_t port, const std::string& address)
{ {
return 1; return 1;
} }
@ -4064,7 +4064,7 @@ int32_t network_get_pickup_peep_old_x(uint8_t playerid)
void network_send_chat(const char* text) void network_send_chat(const char* text)
{ {
} }
void network_send_password(const char* password) void network_send_password(const std::string& password)
{ {
} }
void network_close() void network_close()

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

@ -251,10 +251,10 @@ private:
return key; return key;
} }
static const char* GetMasterServerUrl() static std::string GetMasterServerUrl()
{ {
const char* result = OPENRCT2_MASTER_SERVER_URL; std::string result = OPENRCT2_MASTER_SERVER_URL;
if (!String::IsNullOrEmpty(gConfigNetwork.master_server_url)) if (gConfigNetwork.master_server_url.empty() == false)
{ {
result = gConfigNetwork.master_server_url; result = gConfigNetwork.master_server_url;
} }

14
src/openrct2/network/TcpSocket.cpp
View File

@ -112,10 +112,10 @@ public:
void Listen(uint16_t port) override void Listen(uint16_t port) override
{ {
Listen(nullptr, port); Listen("", port);
} }
void Listen(const char* address, uint16_t port) override void Listen(const std::string& address, uint16_t port) override
{ {
if (_status != SOCKET_STATUS_CLOSED) if (_status != SOCKET_STATUS_CLOSED)
{ {
@ -223,7 +223,7 @@ public:
return tcpSocket; return tcpSocket;
} }
void Connect(const char* address, uint16_t port) override void Connect(const std::string& address, uint16_t port) override
{ {
if (_status != SOCKET_STATUS_CLOSED) if (_status != SOCKET_STATUS_CLOSED)
{ {
@ -315,7 +315,7 @@ public:
} }
} }
void ConnectAsync(const char* address, uint16_t port) override void ConnectAsync(const std::string& address, uint16_t port) override
{ {
if (_status != SOCKET_STATUS_CLOSED) if (_status != SOCKET_STATUS_CLOSED)
{ {
@ -447,19 +447,19 @@ private:
_status = SOCKET_STATUS_CLOSED; _status = SOCKET_STATUS_CLOSED;
} }
bool ResolveAddress(const char* address, uint16_t port, sockaddr_storage* ss, int32_t* ss_len) bool ResolveAddress(const std::string& address, uint16_t port, sockaddr_storage* ss, int32_t* ss_len)
{ {
std::string serviceName = std::to_string(port); std::string serviceName = std::to_string(port);
addrinfo hints = {}; addrinfo hints = {};
hints.ai_family = AF_UNSPEC; hints.ai_family = AF_UNSPEC;
if (address == nullptr) if (address.empty())
{ {
hints.ai_flags = AI_PASSIVE; hints.ai_flags = AI_PASSIVE;
} }
addrinfo* result = nullptr; addrinfo* result = nullptr;
int errorcode = getaddrinfo(address, serviceName.c_str(), &hints, &result); int errorcode = getaddrinfo(address.empty() ? nullptr : address.c_str(), serviceName.c_str(), &hints, &result);
if (errorcode != 0) if (errorcode != 0)
{ {
log_error("Resolving address failed: Code %d.", errorcode); log_error("Resolving address failed: Code %d.", errorcode);

7
src/openrct2/network/TcpSocket.h
View File

@ -12,6 +12,7 @@
#include "../common.h" #include "../common.h"
#include <memory> #include <memory>
#include <string>
enum SOCKET_STATUS enum SOCKET_STATUS
{ {
@ -45,11 +46,11 @@ public:
virtual const char* GetHostName() const abstract; virtual const char* GetHostName() const abstract;
virtual void Listen(uint16_t port) abstract; virtual void Listen(uint16_t port) abstract;
virtual void Listen(const char* address, uint16_t port) abstract; virtual void Listen(const std::string& address, uint16_t port) abstract;
virtual std::unique_ptr<ITcpSocket> Accept() abstract; virtual std::unique_ptr<ITcpSocket> Accept() abstract;
virtual void Connect(const char* address, uint16_t port) abstract; virtual void Connect(const std::string& address, uint16_t port) abstract;
virtual void ConnectAsync(const char* address, uint16_t port) abstract; virtual void ConnectAsync(const std::string& address, uint16_t port) abstract;
virtual size_t SendData(const void* buffer, size_t size) abstract; virtual size_t SendData(const void* buffer, size_t size) abstract;
virtual NETWORK_READPACKET ReceiveData(void* buffer, size_t size, size_t* sizeReceived) abstract; virtual NETWORK_READPACKET ReceiveData(void* buffer, size_t size, size_t* sizeReceived) abstract;

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

@ -31,8 +31,8 @@ namespace OpenRCT2
void network_set_env(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env); void network_set_env(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env);
void network_close(); void network_close();
void network_shutdown_client(); void network_shutdown_client();
int32_t network_begin_client(const char* host, int32_t port); int32_t network_begin_client(const std::string& host, int32_t port);
int32_t network_begin_server(int32_t port, const char* address); int32_t network_begin_server(int32_t port, const std::string& address);
int32_t network_get_mode(); int32_t network_get_mode();
int32_t network_get_status(); int32_t network_get_status();
@ -86,7 +86,7 @@ void network_send_gamecmd(
uint32_t eax, uint32_t ebx, uint32_t ecx, uint32_t edx, uint32_t esi, uint32_t edi, uint32_t ebp, uint8_t callback); uint32_t eax, uint32_t ebx, uint32_t ecx, uint32_t edx, uint32_t esi, uint32_t edi, uint32_t ebp, uint8_t callback);
void network_send_game_action(const GameAction* action); void network_send_game_action(const GameAction* action);
void network_enqueue_game_action(const GameAction* action); void network_enqueue_game_action(const GameAction* action);
void network_send_password(const char* password); void network_send_password(const std::string& password);
void network_set_password(const char* password); void network_set_password(const char* password);