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);
safe_strcpy(_playerName, gConfigNetwork.player_name, sizeof(_playerName));
safe_strcpy(_playerName, gConfigNetwork.player_name.c_str(), sizeof(_playerName));
server_list_load_server_entries();
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)
{
SafeFree(gConfigNetwork.player_name);
gConfigNetwork.player_name = _strdup(_playerName);
gConfigNetwork.player_name = _playerName;
config_save_default();
}
@ -639,8 +638,8 @@ static void join_server(std::string address)
#ifndef DISABLE_HTTP
static void fetch_servers()
{
const char* masterServerUrl = OPENRCT2_MASTER_SERVER_URL;
if (!str_is_null_or_empty(gConfigNetwork.master_server_url))
std::string masterServerUrl = OPENRCT2_MASTER_SERVER_URL;
if (gConfigNetwork.master_server_url.empty() == false)
{
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;
snprintf(_port, 7, "%u", gConfigNetwork.default_port);
safe_strcpy(_name, gConfigNetwork.server_name, sizeof(_name));
safe_strcpy(_description, gConfigNetwork.server_description, sizeof(_description));
safe_strcpy(_greeting, gConfigNetwork.server_greeting, sizeof(_greeting));
safe_strcpy(_name, gConfigNetwork.server_name.c_str(), sizeof(_name));
safe_strcpy(_description, gConfigNetwork.server_description.c_str(), sizeof(_description));
safe_strcpy(_greeting, gConfigNetwork.server_greeting.c_str(), sizeof(_greeting));
return window;
}
@ -153,7 +153,7 @@ static void window_server_start_scenarioselect_callback(const utf8* path)
network_set_password(_password);
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))
{
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)
{
SafeFree(gConfigNetwork.server_name);
gConfigNetwork.server_name = _strdup(_name);
gConfigNetwork.server_name = _name;
config_save_default();
}
@ -286,8 +285,7 @@ static void window_server_start_textinput(rct_window* w, rct_widgetindex widgetI
if (strlen(_description) > 0)
{
SafeFree(gConfigNetwork.server_description);
gConfigNetwork.server_description = _strdup(_description);
gConfigNetwork.server_description = _description;
config_save_default();
}
@ -305,8 +303,7 @@ static void window_server_start_textinput(rct_window* w, rct_widgetindex widgetI
if (strlen(_greeting) > 0)
{
SafeFree(gConfigNetwork.server_greeting);
gConfigNetwork.server_greeting = _strdup(_greeting);
gConfigNetwork.server_greeting = _greeting;
config_save_default();
}

4
src/openrct2/Context.cpp
View File

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

6
src/openrct2/OpenRCT2.h
View File

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

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

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

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

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

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

@ -11,6 +11,8 @@
#include "../common.h"
#include <string>
struct GeneralConfiguration
{
// Paths
@ -135,20 +137,20 @@ struct TwitchConfiguration
struct NetworkConfiguration
{
utf8* player_name;
std::string player_name;
int32_t default_port;
char* listen_address;
utf8* default_password;
std::string listen_address;
std::string default_password;
bool stay_connected;
bool advertise;
int32_t maxplayers;
utf8* server_name;
utf8* server_description;
utf8* server_greeting;
utf8* master_server_url;
utf8* provider_name;
utf8* provider_email;
utf8* provider_website;
std::string server_name;
std::string server_description;
std::string server_greeting;
std::string master_server_url;
std::string provider_name;
std::string provider_email;
std::string provider_website;
bool known_keys_only;
bool log_chat;
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_server_greeting();
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_public_key_path(utf8* buffer, size_t bufferSize, const utf8* playerName, const utf8* hash);
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 std::string& playerName, const utf8* hash);
class Network
{
@ -113,8 +113,8 @@ public:
void SetEnvironment(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env);
bool Init();
void Close();
bool BeginClient(const char* host, uint16_t port);
bool BeginServer(uint16_t port, const char* address);
bool BeginClient(const std::string& host, uint16_t port);
bool BeginServer(uint16_t port, const std::string& address);
int32_t GetMode();
int32_t GetStatus();
int32_t GetAuthStatus();
@ -157,7 +157,9 @@ public:
void CloseServerLog();
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_TOKEN(NetworkConnection& connection);
void Server_Send_MAP(NetworkConnection* connection = nullptr);
@ -209,10 +211,10 @@ private:
void AddClient(std::unique_ptr<ITcpSocket>&& socket);
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);
const char* GetMasterServerUrl();
std::string GetMasterServerUrl();
std::string GenerateAdvertiseKey();
void SetupDefaultGroups();
@ -465,7 +467,7 @@ void Network::CloseConnection()
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)
{
@ -478,7 +480,7 @@ bool Network::BeginClient(const char* host, uint16_t port)
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->Socket = CreateTcpSocket();
@ -557,7 +559,7 @@ bool Network::BeginClient(const char* host, uint16_t port)
return true;
}
bool Network::BeginServer(uint16_t port, const char* address)
bool Network::BeginServer(uint16_t port, const std::string& address)
{
Close();
if (!Init())
@ -567,9 +569,6 @@ bool Network::BeginServer(uint16_t port, const char* address)
_userManager.Load();
if (strlen(address) == 0)
address = nullptr;
log_verbose("Begin listening for clients");
_listenSocket = CreateTcpSocket();
@ -584,12 +583,12 @@ bool Network::BeginServer(uint16_t port, const char* address)
return false;
}
ServerName = String::ToStd(gConfigNetwork.server_name);
ServerDescription = String::ToStd(gConfigNetwork.server_description);
ServerGreeting = String::ToStd(gConfigNetwork.server_greeting);
ServerProviderName = String::ToStd(gConfigNetwork.provider_name);
ServerProviderEmail = String::ToStd(gConfigNetwork.provider_email);
ServerProviderWebsite = String::ToStd(gConfigNetwork.provider_website);
ServerName = gConfigNetwork.server_name;
ServerDescription = gConfigNetwork.server_description;
ServerGreeting = gConfigNetwork.server_greeting;
ServerProviderName = gConfigNetwork.provider_name;
ServerProviderEmail = gConfigNetwork.provider_email;
ServerProviderWebsite = gConfigNetwork.provider_website;
cheats_reset();
LoadGroups();
@ -1028,9 +1027,9 @@ std::string Network::GenerateAdvertiseKey()
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;
}
@ -1351,17 +1350,18 @@ void Network::Client_Send_TOKEN()
_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());
*packet << (uint32_t)NETWORK_COMMAND_AUTH;
packet->WriteString(network_get_version().c_str());
packet->WriteString(name);
packet->WriteString(password);
packet->WriteString(pubkey);
packet->WriteString(name.c_str());
packet->WriteString(password.c_str());
packet->WriteString(pubkey.c_str());
assert(sigsize <= (size_t)UINT32_MAX);
*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->QueuePacket(std::move(packet));
}
@ -1700,20 +1700,20 @@ void Network::Server_Send_GAMEINFO(NetworkConnection& connection)
*packet << (uint32_t)NETWORK_COMMAND_GAMEINFO;
# ifndef DISABLE_HTTP
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, "version", json_string(network_get_version().c_str()));
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, "description", json_string(gConfigNetwork.server_description));
json_object_set_new(obj, "greeting", json_string(gConfigNetwork.server_greeting));
json_object_set_new(obj, "description", json_string(gConfigNetwork.server_description.c_str()));
json_object_set_new(obj, "greeting", json_string(gConfigNetwork.server_greeting.c_str()));
json_object_set_new(obj, "dedicated", json_boolean(gOpenRCT2Headless));
// Provider details
json_t* jsonProvider = json_object();
json_object_set_new(jsonProvider, "name", json_string(gConfigNetwork.provider_name));
json_object_set_new(jsonProvider, "email", json_string(gConfigNetwork.provider_email));
json_object_set_new(jsonProvider, "website", json_string(gConfigNetwork.provider_website));
json_object_set_new(jsonProvider, "name", json_string(gConfigNetwork.provider_name.c_str()));
json_object_set_new(jsonProvider, "email", json_string(gConfigNetwork.provider_email.c_str()));
json_object_set_new(jsonProvider, "website", json_string(gConfigNetwork.provider_website.c_str()));
json_object_set_new(obj, "provider", jsonProvider);
packet->WriteString(json_dumps(obj, 0));
@ -2053,7 +2053,7 @@ void Network::RemoveClient(std::unique_ptr<NetworkConnection>& connection)
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;
int32_t newid = -1;
@ -2093,9 +2093,9 @@ NetworkPlayer* Network::AddPlayer(const utf8* name, const std::string& keyhash)
if (networkUser == nullptr)
{
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
@ -2205,7 +2205,7 @@ void Network::Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket&
_key.Unload();
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;
}
@ -3082,12 +3082,12 @@ void network_shutdown_client()
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);
}
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);
}
@ -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];
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
// when process dump gets collected at some point in future.
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;
}
@ -3838,17 +3838,17 @@ static void network_get_keys_directory(utf8* buffer, size_t 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);
Path::Append(buffer, bufferSize, playerName);
Path::Append(buffer, bufferSize, playerName.c_str());
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);
Path::Append(buffer, bufferSize, playerName);
Path::Append(buffer, bufferSize, playerName.c_str());
String::Append(buffer, bufferSize, "-");
String::Append(buffer, bufferSize, hash);
String::Append(buffer, bufferSize, ".pubkey");
@ -3934,11 +3934,11 @@ void network_update()
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;
}
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;
}
@ -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_password(const char* password)
void network_send_password(const std::string& password)
{
}
void network_close()

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

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

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

@ -112,10 +112,10 @@ public:
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)
{
@ -223,7 +223,7 @@ public:
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)
{
@ -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)
{
@ -447,19 +447,19 @@ private:
_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);
addrinfo hints = {};
hints.ai_family = AF_UNSPEC;
if (address == nullptr)
if (address.empty())
{
hints.ai_flags = AI_PASSIVE;
}
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)
{
log_error("Resolving address failed: Code %d.", errorcode);

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

@ -12,6 +12,7 @@
#include "../common.h"
#include <memory>
#include <string>
enum SOCKET_STATUS
{
@ -45,11 +46,11 @@ public:
virtual const char* GetHostName() const 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 void Connect(const char* address, uint16_t port) abstract;
virtual void ConnectAsync(const char* address, uint16_t port) abstract;
virtual void Connect(const std::string& 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 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_close();
void network_shutdown_client();
int32_t network_begin_client(const char* host, int32_t port);
int32_t network_begin_server(int32_t port, const char* address);
int32_t network_begin_client(const std::string& host, int32_t port);
int32_t network_begin_server(int32_t port, const std::string& address);
int32_t network_get_mode();
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);
void network_send_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);